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

package/src/schemaUpgrader.ts

@@ -0,0 +1,653 @@
+import {
+    ASTNode,
+  GraphQLError,
+  Kind,
+  print as printAST,
+} from "graphql";
+import { ERRORS } from "./error";
+import {
+  baseType,
+  Directive,
+  errorCauses,
+  Extension,
+  FieldDefinition,
+  isCompositeType,
+  isInterfaceType,
+  isObjectType,
+  NamedSchemaElement,
+  NamedType,
+  ObjectType,
+  Schema,
+  SchemaElement,
+} from "./definitions";
+import {
+  addSubgraphToError,
+  collectTargetFields,
+  federationMetadata,
+  FederationMetadata,
+  printSubgraphNames,
+  removeInactiveProvidesAndRequires,
+  setSchemaAsFed2Subgraph,
+  Subgraph,
+  Subgraphs,
+} from "./federation";
+import { assert, firstOf, MultiMap } from "./utils";
+import { FEDERATION_SPEC_TYPES } from "./federationSpec";
+
+export type UpgradeResult = UpgradeSuccess | UpgradeFailure;
+
+type UpgradeChanges = MultiMap<UpgradeChangeID, UpgradeChange>;
+
+export type UpgradeSuccess = {
+  subgraphs: Subgraphs,
+  changes: Map<string, UpgradeChanges>,
+  errors?: never,
+}
+
+export type UpgradeFailure = {
+  subgraphs?: never,
+  changes?: never,
+  errors: GraphQLError[],
+}
+
+export type UpgradeChangeID = UpgradeChange['id'];
+
+export type UpgradeChange =
+  ExternalOnTypeExtensionRemoval
+  | TypeExtensionRemoval
+  | UnusedExternalRemoval
+  | TypeWithOnlyUnusedExternalRemoval
+  | ExternalOnInterfaceRemoval
+  | InactiveProvidesOrRequiresRemoval
+  | InactiveProvidesOrRequiresFieldsRemoval
+  | ShareableFieldAddition
+  | ShareableTypeAddition
+  | KeyOnInterfaceRemoval
+  | ProvidesOrRequiresOnInterfaceFieldRemoval
+  | ProvidesOnNonCompositeRemoval
+  | FieldsArgumentCoercionToString
+;
+
+export class ExternalOnTypeExtensionRemoval {
+  readonly id = 'EXTERNAL_ON_TYPE_EXTENSION_REMOVAL' as const;
+
+  constructor(readonly field: string) {}
+
+  toString() {
+    return `Removed @external from field "${this.field}" as it is a key of an extension type`;
+  }
+}
+
+export class TypeExtensionRemoval {
+  readonly id = 'TYPE_EXTENSION_REMOVAL' as const;
+
+  constructor(readonly type: string) {}
+
+  toString() {
+    return `Switched type "${this.type}" from an extension to a definition`;
+  }
+}
+
+export class ExternalOnInterfaceRemoval {
+  readonly id = 'EXTERNAL_ON_INTERFACE_REMOVAL' as const;
+
+  constructor(readonly field: string) {}
+
+  toString() {
+    return `Removed @external directive on interface type field "${this.field}": @external is nonsensical on interface fields`;
+  }
+}
+
+export class UnusedExternalRemoval {
+  readonly id = 'UNUSED_EXTERNAL_REMOVAL' as const;
+
+  constructor(readonly field: string) {}
+
+  toString() {
+    return `Removed @external field "${this.field}" as it was not used in any @key, @provides or @requires`;
+  }
+}
+
+export class TypeWithOnlyUnusedExternalRemoval {
+  readonly id = 'TYPE_WITH_ONLY_UNUSED_EXTERNAL_REMOVAL' as const;
+
+  constructor(readonly type: string) {}
+
+  toString() {
+    return `Removed type ${this.type} that is not referenced in the schema and only declares unused @external fields`;
+  }
+}
+
+export class InactiveProvidesOrRequiresRemoval {
+  readonly id = 'INACTIVE_PROVIDES_OR_REQUIRES_REMOVAL' as const;
+
+  constructor(readonly parent: string, readonly removed: string) {}
+
+  toString() {
+    return `Removed directive ${this.removed} on "${this.parent}": none of the fields were truly @external`;
+  }
+}
+
+export class InactiveProvidesOrRequiresFieldsRemoval {
+  readonly id = 'INACTIVE_PROVIDES_OR_REQUIRES_FIELDS_REMOVAL' as const;
+
+  constructor(readonly parent: string, readonly original: string, readonly updated: string) {}
+
+  toString() {
+    return `Updated directive ${this.original} on "${this.parent}" to ${this.updated}: removed fields that were not truly @external`;
+  }
+}
+
+export class ShareableFieldAddition {
+  readonly id = 'SHAREABLE_FIELD_ADDITION' as const;
+
+  constructor(readonly field: string, readonly declaringSubgraphs: string[]) {}
+
+  toString() {
+    return `Added @shareable to field "${this.field}": it is also resolved by ${printSubgraphNames(this.declaringSubgraphs)}`;
+  }
+}
+
+export class ShareableTypeAddition {
+  readonly id = 'SHAREABLE_TYPE_ADDITION' as const;
+
+  constructor(readonly type: string, readonly declaringSubgraphs: string[]) {}
+
+  toString() {
+    return `Added @shareable to type "${this.type}": it is a "value type" and is also declared in ${printSubgraphNames(this.declaringSubgraphs)}`;
+  }
+}
+
+export class KeyOnInterfaceRemoval {
+  readonly id = 'KEY_ON_INTERFACE_REMOVAL' as const;
+
+  constructor(readonly type: string) {}
+
+  toString() {
+    return `Removed @key on interface "${this.type}": while allowed by federation 0.x, @key on interfaces were completely ignored/had no effect`;
+  }
+}
+
+export class ProvidesOrRequiresOnInterfaceFieldRemoval {
+  readonly id = 'PROVIDES_OR_REQUIRES_ON_INTERFACE_FIELD_REMOVAL' as const;
+
+  constructor(readonly field: string, readonly directive: string) {}
+
+  toString() {
+    return `Removed @${this.directive} on interface field "${this.field}": while allowed by federation 0.x, @${this.directive} on interface fields were completely ignored/had no effect`;
+  }
+}
+
+export class ProvidesOnNonCompositeRemoval {
+  readonly id = 'PROVIDES_ON_NON_COMPOSITE_REMOVAL' as const;
+
+  constructor(readonly field: string, readonly type: string) {}
+
+  toString() {
+    return `Removed @provides directive on field "${this.field}" as it is of non-composite type "${this.type}": while not rejected by federation 0.x, such @provide is nonsensical and was ignored`;
+  }
+}
+
+export class FieldsArgumentCoercionToString {
+  readonly id = 'FIELDS_ARGUMENT_COERCION_TO_STRING' as const;
+
+  constructor(readonly element: string, readonly directive: string, readonly before: string, readonly after: string) {}
+
+  toString() {
+    return `Coerced "fields" argument for directive @${this.directive} for "${this.element}" into a string: coerced from ${this.before} to ${this.after}`;
+  }
+}
+
+export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
+  const changes: Map<string, UpgradeChanges> = new Map();
+  if (inputs.values().every((s) => s.isFed2Subgraph())) {
+    return { subgraphs: inputs, changes };
+  }
+
+  const subgraphs = new Subgraphs();
+  let errors: GraphQLError[] = [];
+  for (const subgraph of inputs.values()) {
+    if (subgraph.isFed2Subgraph()) {
+      subgraphs.add(subgraph);
+    } else {
+      const otherSubgraphs = inputs.values().filter((s) => s.name !== subgraph.name);
+      const res = new SchemaUpgrader(subgraph, otherSubgraphs).upgrade();
+      if (res.errors) {
+        errors = errors.concat(res.errors);
+      } else {
+        subgraphs.add(res.upgraded);
+        changes.set(subgraph.name, res.changes);
+      }
+    }
+  }
+  return errors.length === 0 ? { subgraphs, changes } : { errors };
+}
+
+/**
+ * Wether the type represents a type extension in the sense of federation 1.
+ * That is, type extension are a thing in GraphQL, but federation 1 overloads the notion for entities. This method
+ * return true if the type is used in the federation 1 sense of an extension.
+ * And we recognize federation 1 type extensions as type extension that:
+ *  1. are on object type or interface type (note that federation 1 don't really handle interface type extension properly but it "accepts" them
+ *     so we do it here too).
+ *  2. do not have a definition for the same type in the same subgraph (this is a GraphQL extension otherwise).
+ *
+ * Not that type extensions in federation 1 generally have a @key but in really the code consider something a type extension even without
+ * it (which I'd argue is a unintended bug of fed1 since this leads to various problems) so we don't check for the presence of @key here.
+ */
+function isFederationTypeExtension(type: NamedType): boolean {
+  const metadata = federationMetadata(type.schema());
+  assert(metadata, 'Should be a subgraph schema');
+  const hasExtend = type.hasAppliedDirective(metadata.extendsDirective());
+  return (type.hasExtensionElements() || hasExtend)
+    && (isObjectType(type) || isInterfaceType(type))
+    && (hasExtend || !type.hasNonExtensionElements());
+}
+
+/**
+ * Whether the type is a root type but is declared has (only) an extension, which federation 1 actually accepts.
+ */
+function isRootTypeExtension(type: NamedType): boolean {
+  const metadata = federationMetadata(type.schema());
+  assert(metadata, 'Should be a subgraph schema');
+  return isObjectType(type)
+    && type.isRootType()
+    && (type.hasAppliedDirective(metadata.extendsDirective()) || (type.hasExtensionElements() && !type.hasNonExtensionElements()));
+}
+
+function resolvesField(subgraph: Subgraph, field: FieldDefinition<ObjectType>): boolean  {
+  const metadata = subgraph.metadata();
+  const t = subgraph.schema.type(field.parent.name);
+  if (!t || !isObjectType(t)) {
+    return false;
+  }
+  const f = t.field(field.name);
+  return !!f && (!metadata.isFieldExternal(f) || metadata.isFieldPartiallyExternal(f));
+}
+
+class SchemaUpgrader {
+  private readonly changes = new MultiMap<UpgradeChangeID, UpgradeChange>();
+  private readonly schema: Schema;
+  private readonly subgraph: Subgraph;
+  private readonly metadata: FederationMetadata;
+  private readonly errors: GraphQLError[] = [];
+
+  constructor(private readonly originalSubgraph: Subgraph, private readonly otherSubgraphs: Subgraph[]) {
+    // Note that as we clone the original schema, the 'sourceAST' values in the elements of the new schema will be those of the original schema
+    // and those won't be updated as we modify the schema to make it fed2-enabled. This is _important_ for us here as this is what ensures that
+    // later merge errors "AST" nodes ends up pointing to the original schema, the one that make sense to the user.
+    this.schema = originalSubgraph.schema.clone();
+    this.renameFederationTypes();
+    setSchemaAsFed2Subgraph(this.schema);
+    this.subgraph = new Subgraph(originalSubgraph.name, originalSubgraph.url, this.schema);
+    this.metadata = this.subgraph.metadata();
+  }
+
+  private addError(e: GraphQLError): void {
+    this.errors.push(addSubgraphToError(e, this.subgraph.name, ERRORS.INVALID_GRAPHQL));
+  }
+
+  private renameFederationTypes() {
+    // When we set the upgraded schema as a fed2 schema, we only "import" the federation directives, but not the federation types. This
+    // means that those types will be called `_Entity`, `_Any`, ... in the fed1 original schema, but they should be called `federation__Entity`,
+    // `federation__Any`, ... in the new upgraded schema.
+    // But note that even "importing" those types would not completely work because fed2 essentially drops the `_` at the beginning of those
+    // type names (relying on the core schema prefixing instead) and so some special translation needs to happen.
+    for (const typeSpec of FEDERATION_SPEC_TYPES) {
+      const typeNameInOriginal = this.originalSubgraph.metadata().federationTypeNameInSchema(typeSpec.name);
+      const type = this.schema.type(typeNameInOriginal);
+      if (type) {
+        type.rename(`federation__${typeSpec.name}`);
+      }
+    }
+  }
+
+  private external(elt: FieldDefinition<any>): Directive<any, {}> | undefined {
+    const applications = elt.appliedDirectivesOf(this.metadata.externalDirective());
+    return applications.length === 0 ? undefined : applications[0];
+  }
+
+  private addChange(change: UpgradeChange) {
+    this.changes.add(change.id, change);
+  }
+
+  private checkForExtensionWithNoBase(type: NamedType): void {
+    // The checks that if the type is a "federation 1" type extension, then another subgraph has a proper definition
+    // for that type.
+    if (isRootTypeExtension(type) || !isFederationTypeExtension(type)) {
+      return;
+    }
+
+    const extensionAST = firstOf<Extension<any>>(type.extensions().values())?.sourceAST;
+    for (const subgraph of this.otherSubgraphs) {
+      const otherType = subgraph.schema.type(type.name);
+      if (otherType && otherType.hasNonExtensionElements()) {
+        return;
+      }
+    }
+
+    // We look at all the other subgraphs and didn't found a (non-extension) definition of that type
+    this.addError(ERRORS.EXTENSION_WITH_NO_BASE.err({
+      message: `Type "${type}" is an extension type, but there is no type definition for "${type}" in any subgraph.`,
+      nodes: extensionAST,
+    }));
+  }
+
+  private preUpgradeValidations(): void {
+    for (const type of this.schema.types()) {
+     this.checkForExtensionWithNoBase(type);
+    }
+  }
+
+  upgrade(): { upgraded: Subgraph, changes: UpgradeChanges, errors?: never } | { errors: GraphQLError[] } {
+    this.preUpgradeValidations();
+
+    this.fixFederationDirectivesArguments();
+
+    this.removeExternalOnInterface();
+
+    // Note that we remove all external on type extensions first, so we don't have to care about it later in @key, @provides and @requires.
+    this.removeExternalOnTypeExtensions();
+
+    this.fixInactiveProvidesAndRequires();
+
+    this.removeTypeExtensions();
+
+    this.removeDirectivesOnInterface();
+
+    // Note that this rule rely on being after `removeDirectivesOnInterface` in practice (in that it doesn't check interfaces).
+    this.removeProvidesOnNonComposite();
+
+    // Note that this should come _after_ all the other changes that may remove/update federation directives, since those may create unused
+    // externals. Which is why this is toward  the end.
+    this.removeUnusedExternals();
+
+    this.addShareable();
+
+    // If we had errors during the upgrade, we throw them before trying to validate the resulting subgraph, because any invalidity in the
+    // migrated subgraph may well due to those migration errors and confuse users.
+    if (this.errors.length > 0) {
+      return { errors: this.errors };
+    }
+
+    try {
+      this.subgraph.validate();
+      return {
+        upgraded: this.subgraph,
+        changes: this.changes,
+      };
+    } catch (e) {
+      const errors = errorCauses(e);
+      if (!errors) {
+        throw e;
+      }
+      // Do note that it's genuinely possible to return errors here, because federation validations (validating @key, @provides, ...) is mostly
+      // not done on the input schema and will only be triggered now, on the upgraded schema. Importantly, the errors returned here shouldn't
+      // be due to the upgrade process, but either due to the fed1 schema being invalid in the first place, or due to validation of fed2 that
+      // cannot be dealt with by the upgrade process (like, for instance, the fact that fed1 doesn't always reject fields mentioned in a @key
+      // that are not defined in the subgraph, but fed2 consistently do).
+      return { errors };
+    }
+  }
+
+  private fixFederationDirectivesArguments() {
+    for (const directive of [this.metadata.keyDirective(), this.metadata.requiresDirective(), this.metadata.providesDirective()]) {
+      for (const application of directive.applications()) {
+        const fields = application.arguments().fields;
+        if (typeof fields !== 'string') {
+          // The one case we have seen in practice is user passing an array of string, so we handle that. If it's something else,
+          // it's probably just completely invalid, so we ignore the application and let validation complain later.
+          if (Array.isArray(fields) && fields.every((f) => typeof f === 'string')) {
+            this.replaceFederationDirectiveApplication(application, application.toString(), fields.join(' '), directive.sourceAST);
+          }
+          continue;
+        }
+
+        // While validating if the field is a string will work in most cases, this will not catch the case where the field argument was
+        // unquoted but parsed as an enum value (see federation/issues/850 in particular). So if we have the AST (which we will usually
+        // have in practice), use that to check that the argument was truly a string.
+        const nodes = application.sourceAST;
+        if (nodes && nodes.kind === 'Directive') {
+          for (const argNode of nodes.arguments ?? []) {
+            if (argNode.name.value === 'fields') {
+              if (argNode.value.kind === Kind.ENUM) {
+                // Note that we we mostly want here is replacing the sourceAST because that is what is later used by validation
+                // to detect the problem.
+                this.replaceFederationDirectiveApplication(application, printAST(nodes), fields, {
+                  ...nodes,
+                  arguments: [{
+                    ...argNode,
+                    value: {
+                      kind: Kind.STRING,
+                      value: fields
+                    }
+                  }]
+                })
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private removeExternalOnInterface() {
+    for (const itf of this.schema.interfaceTypes()) {
+      for (const field of itf.fields()) {
+        const external = this.external(field);
+        if (external) {
+          this.addChange(new ExternalOnInterfaceRemoval(field.coordinate));
+          external.remove();
+        }
+      }
+    }
+  }
+
+  private replaceFederationDirectiveApplication(
+    application: Directive<SchemaElement<any, any>, {fields: any}>,
+    before: string,
+    fields: string,
+    updatedSourceAST: ASTNode | undefined,
+  ) {
+    const directive = application.definition!;
+    // Note that in practice, federation directives can only be on either a type or a field, both of which are named.
+    const parent = application.parent as NamedSchemaElement<any, any, any>;
+    application.remove();
+    const newDirective = parent.applyDirective(directive, {fields});
+    newDirective.sourceAST = updatedSourceAST;
+    this.addChange(new FieldsArgumentCoercionToString(parent.coordinate, directive.name, before, newDirective.toString()));
+  }
+
+  private fixInactiveProvidesAndRequires() {
+    removeInactiveProvidesAndRequires(
+      this.schema,
+      (field, original, updated) => {
+        if (updated) {
+          this.addChange(new InactiveProvidesOrRequiresFieldsRemoval(field.coordinate, original.toString(), updated.toString()));
+        } else {
+          this.addChange(new InactiveProvidesOrRequiresRemoval(field.coordinate, original.toString()));
+        }
+      }
+    );
+  }
+
+  private removeExternalOnTypeExtensions() {
+    for (const type of this.schema.types()) {
+      if (!isCompositeType(type)) {
+        continue;
+      }
+      if (!isFederationTypeExtension(type) && !isRootTypeExtension(type)) {
+        continue;
+      }
+
+      const keyApplications = type.appliedDirectivesOf(this.metadata.keyDirective());
+      if (keyApplications.length > 0) {
+        // If the type extension has keys, then fed1 will essentially consider the key fields not external ...
+        for (const keyApplication of type.appliedDirectivesOf(this.metadata.keyDirective())) {
+          collectTargetFields({
+            parentType: type,
+            directive: keyApplication,
+            includeInterfaceFieldsImplementations: false,
+            validate: false,
+          }).forEach((field) => {
+            // We only consider "top-level" fields, the one of the type on which the key is, because that's what fed1 does.
+            if (field.parent !== type) {
+              return;
+            }
+            const external = this.external(field);
+            if (external) {
+              this.addChange(new ExternalOnTypeExtensionRemoval(field.coordinate));
+              external.remove();
+            }
+          });
+        }
+      } else {
+        // ... but if the extension does _not_ have a key, then if the extension has a field that is
+        // part of the _1st_ key on the subgraph owning the type, then this field is not considered
+        // external (yes, it's pretty damn random, and it's even worst in that even if the extension
+        // does _not_ have the "field of the _1st_ key on the subraph owning the type", then the
+        // query planner will still request it to the subgraph, generating an invalid query; but
+        // we ignore that here). Note however that because other subgraphs may have already been
+        // upgraded, we don't know which is the "type owner", so instead we look up at the first
+        // key of every other subgraph. It's not 100% what fed1 does, but we're in very-strange
+        // case territory in the first place, so this is probably good enough (that is, there is
+        // customer schema for which what we do here matter but not that I know of for which it's
+        // not good enough).
+        for (const other of this.otherSubgraphs) {
+          const typeInOther = other.schema.type(type.name);
+          if (!typeInOther) {
+            continue;
+          }
+          assert(isCompositeType(typeInOther), () => `Type ${type} is of kind ${type.kind} in ${this.subgraph.name} but ${typeInOther.kind} in ${other.name}`);
+          const keysInOther = typeInOther.appliedDirectivesOf(other.metadata().keyDirective());
+          if (keysInOther.length === 0) {
+            continue;
+          }
+          collectTargetFields({
+            parentType: typeInOther,
+            directive: keysInOther[0],
+            includeInterfaceFieldsImplementations: false,
+            validate: false,
+          }).forEach((field) => {
+            if (field.parent !== typeInOther) {
+              return;
+            }
+            // Remark that we're iterating on the fields of _another_ subgraph that the one we're upgrading.
+            // We only consider "top-level" fields, the one of the type on which the key is, because that's what fed1 does.
+            const ownField = type.field(field.name);
+            if (!ownField) {
+              return;
+            }
+            const external = this.external(ownField);
+            if (external) {
+              this.addChange(new ExternalOnTypeExtensionRemoval(ownField.coordinate));
+              external.remove();
+            }
+          });
+        }
+      }
+    }
+  }
+
+  private removeTypeExtensions() {
+    for (const type of this.schema.types()) {
+      if (!isFederationTypeExtension(type) && !isRootTypeExtension(type)) {
+        continue;
+      }
+
+      this.addChange(new TypeExtensionRemoval(type.coordinate));
+      type.removeExtensions();
+    }
+  }
+
+  private removeUnusedExternals() {
+    for (const type of this.schema.types()) {
+      if (!isObjectType(type) && !isInterfaceType(type)) {
+        continue;
+      }
+      for (const field of type.fields()) {
+        if (this.metadata.isFieldExternal(field) && !this.metadata.isFieldUsed(field)) {
+          this.addChange(new UnusedExternalRemoval(field.coordinate));
+          field.remove();
+        }
+      }
+      if (!type.hasFields()) {
+        if (type.isReferenced()) {
+          this.addError(ERRORS.TYPE_WITH_ONLY_UNUSED_EXTERNAL.err({
+            message: `Type ${type} contains only external fields and all those fields are all unused (they do not appear in any @key, @provides or @requires).`,
+            nodes: type.sourceAST
+          }));
+        } else {
+          // The type only had unused externals, but it is also unreferenced in the subgraph. Unclear why
+          // it was there in the first place, but we can remove it and move on.
+          this.addChange(new TypeWithOnlyUnusedExternalRemoval(type.name));
+          type.remove();
+        }
+      }
+    }
+  }
+
+  private removeDirectivesOnInterface() {
+    for (const type of this.schema.interfaceTypes()) {
+      for (const application of type.appliedDirectivesOf(this.metadata.keyDirective())) {
+        this.addChange(new KeyOnInterfaceRemoval(type.name));
+        application.remove();
+      }
+      for (const field of type.fields()) {
+        for (const directive of [this.metadata.providesDirective(), this.metadata.requiresDirective()]) {
+          for (const application of field.appliedDirectivesOf(directive)) {
+            this.addChange(new ProvidesOrRequiresOnInterfaceFieldRemoval(field.coordinate, directive.name));
+            application.remove();
+          }
+        }
+      }
+    }
+  }
+
+  private removeProvidesOnNonComposite() {
+    for (const type of this.schema.objectTypes()) {
+      for (const field of type.fields()) {
+        if (isCompositeType(baseType(field.type!))) {
+          continue;
+        }
+        for (const application of field.appliedDirectivesOf(this.metadata.providesDirective())) {
+          this.addChange(new ProvidesOnNonCompositeRemoval(field.coordinate, field.type!.toString()));
+          application.remove();
+        }
+      }
+    }
+  }
+
+  private addShareable() {
+    const originalMetadata = this.originalSubgraph.metadata();
+    const keyDirective = this.metadata.keyDirective();
+    const shareableDirective = this.metadata.shareableDirective();
+    // We add shareable:
+    // - to every "value type" (in the fed1 sense of non-root type and non-entity) if it is used in any other subgraphs
+    // - to any (non-external) field of an entity/root-type that is not a key field and if another subgraphs resolve it (fully or partially through @provides)
+    for (const type of this.schema.objectTypes()) {
+      if (type.hasAppliedDirective(keyDirective) || type.isRootType()) {
+        for (const field of type.fields()) {
+          // To know if the field is a "key" field which doesn't need shareable, we rely on whether the field is shareable in the original
+          // schema (the fed1 version), because as fed1 schema will have no @shareable, the key fields will effectively be the only field
+          // considered shareable.
+          if (originalMetadata.isFieldShareable(field)) {
+            continue;
+          }
+          const otherResolvingSubgraphs = this.otherSubgraphs.filter((s) => resolvesField(s, field));
+          if (otherResolvingSubgraphs.length > 0) {
+            field.applyDirective(shareableDirective);
+            this.addChange(new ShareableFieldAddition(field.coordinate, otherResolvingSubgraphs.map((s) => s.name)));
+          }
+        }
+      } else {
+        const otherDeclaringSubgraphs = this.otherSubgraphs.filter((s) => s.schema.type(type.name));
+        if (otherDeclaringSubgraphs.length > 0) {
+          type.applyDirective(shareableDirective);
+          this.addChange(new ShareableTypeAddition(type.coordinate, otherDeclaringSubgraphs.map((s) => s.name)));
+        }
+      }
+    }
+  }
+}

package/src/suggestions.ts

@@ -5,7 +5,7 @@ import { mapKeys } from './utils';
  * Given an invalid input string and a list of valid options, returns a filtered
  * list of valid options sorted based on their similarity with the input.
  */
-export function suggestionList(input: string, options: string[]): string[] {
+export function suggestionList(input: string, options: readonly string[]): string[] {
   const optionsByDistance = new Map<string, number>();
 
   const threshold = Math.floor(input.length * 0.4) + 1;

package/src/supergraphs.ts

@@ -1,7 +1,7 @@
 import { ASTNode, DocumentNode, GraphQLError } from "graphql";
 import { err } from '@apollo/core-schema';
 import { ErrCoreCheckFailed, FeatureUrl, FeatureVersion } from "./coreSpec";
-import { CoreFeature, CoreFeatures, graphQLBuiltIns, Schema } from "./definitions";
+import { CoreFeature, CoreFeatures, Schema } from "./definitions";
 import { joinIdentity, JoinSpecDefinition, JOIN_VERSIONS } from "./joinSpec";
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
 import { extractSubgraphsNamesAndUrlsFromSupergraph } from "./extractSubgraphsFromSupergraph";
@@ -12,6 +12,7 @@ const SUPPORTED_FEATURES = new Set([
   'https://specs.apollo.dev/join/v0.1',
   'https://specs.apollo.dev/join/v0.2',
   'https://specs.apollo.dev/tag/v0.1',
+  'https://specs.apollo.dev/tag/v0.2',
   'https://specs.apollo.dev/inaccessible/v0.1',
 ]);
 
@@ -38,8 +39,8 @@ const coreVersionZeroDotOneUrl = FeatureUrl.parse('https://specs.apollo.dev/core
 export function buildSupergraphSchema(supergraphSdl: string | DocumentNode): [Schema, {name: string, url: string}[]] {
   // We delay validation because `checkFeatureSupport` gives slightly more useful errors if, say, 'for' is used with core v0.1.
   const schema = typeof supergraphSdl === 'string'
-    ? buildSchema(supergraphSdl, graphQLBuiltIns, false)
-    : buildSchemaFromAST(supergraphSdl, graphQLBuiltIns, false);
+    ? buildSchema(supergraphSdl, { validate: false })
+    : buildSchemaFromAST(supergraphSdl, { validate: false });
 
   const [coreFeatures] = validateSupergraph(schema);
   checkFeatureSupport(coreFeatures);