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

package/src/directiveAndTypeSpecification.ts

@@ -0,0 +1,353 @@
+import { ASTNode, DirectiveLocation, GraphQLError } from "graphql";
+import {
+  ArgumentDefinition,
+  DirectiveDefinition,
+  EnumType,
+  InputType,
+  isCustomScalarType,
+  isEnumType,
+  isListType,
+  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, nameInSchema?: string) => { args: ArgumentSpecification[], errors: GraphQLError[] },
+}): DirectiveSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const {args, errors} = argumentFct ? argumentFct(schema, actualName) : { args: [], errors: []};
+      if (errors.length > 0) {
+        return errors;
+      }
+      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 [];
+      }
+    },
+  }
+}
+
+export function createEnumTypeSpecification({
+  name,
+  values,
+}: {
+  name: string,
+  values: { name: string, description?: string}[],
+}): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const existing = schema.type(actualName);
+      const expectedValueNames = values.map((v) => v.name).sort((n1, n2) => n1.localeCompare(n2));
+      if (existing) {
+        let errors = ensureSameTypeKind('EnumType', existing);
+        if (errors.length > 0) {
+          return errors;
+        }
+        assert(isEnumType(existing), 'Should be an enum type');
+        const actualValueNames = existing.values.map(v => v.name).sort((n1, n2) => n1.localeCompare(n2));
+        if (!arrayEquals(expectedValueNames, actualValueNames)) {
+          errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
+            message: `Invalid definition of type ${name}: expected values [${expectedValueNames}] but found [${actualValueNames}].`,
+            nodes: existing.sourceAST
+          }));
+        }
+        return errors;
+      } else {
+        const type = schema.addType(new EnumType(actualName, asBuiltIn));
+        for (const {name, description} of values) {
+          type.addValue(name).description = description;
+        }
+        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[] {
+  const directiveName = `"@${expected.name}"`
+  let errors = ensureSameArguments(expected, actual, `directive ${directiveName}`);
+  // 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 ${directiveName}: ${directiveName} 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 definition for directive ${directiveName}: ${directiveName} 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,
+  containerSourceAST?: ASTNode,
+): GraphQLError[] {
+  const expectedArguments = expected.args ?? [];
+  const errors: GraphQLError[] = [];
+  for (const { name, type, defaultValue } of expectedArguments) {
+    const actualArgument = actual.argument(name);
+    if (!actualArgument) {
+      // Not declaring an optional argument is ok: that means you won't be able to pass a non-default value in your schema, but we allow you that.
+      // But missing a required argument it not ok.
+      if (isNonNullType(type) && defaultValue === undefined) {
+        errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+          message: `Invalid definition for ${what}: missing required argument "${name}"`,
+          nodes: containerSourceAST
+        }));
+      }
+      continue;
+    }
+
+    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) && !isValidInputTypeRedefinition(type, actualType)) {
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: argument "${name}" should have type "${type}" but found type "${actualArgument.type!}"`,
+        nodes: actualArgument.sourceAST
+      }));
+    } else if (!isNonNullType(actualArgument.type!) && !valueEquals(defaultValue, actualArgument.defaultValue)) {
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: argument "${name}" should have default value ${valueToString(defaultValue)} but found default value ${valueToString(actualArgument.defaultValue)}`,
+        nodes: actualArgument.sourceAST
+      }));
+    }
+  }
+  for (const actualArgument of actual.arguments()) {
+    // If it's an expect argument, we already validated it. But we still need to reject unkown argument.
+    if (!expectedArguments.some((arg) => arg.name === actualArgument.name)) {
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: unknown/unsupported argument "${actualArgument.name}"`,
+        nodes: actualArgument.sourceAST
+      }));
+    }
+  }
+  return errors;
+}
+
+function isValidInputTypeRedefinition(expectedType: InputType, actualType: InputType): boolean {
+  // If the expected type is a custom scalar, then we allow the redefinition to be another type (unless it's a custom scalar, in which
+  // case it has to be the same scalar). The rational being that since graphQL does no validation of values passed to a custom scalar,
+  // any code that gets some value as input for a custom scalar has to do validation manually, and so there is little harm in allowing
+  // a redefinition with another type since any truly invalid value would failed that "manual validation". In practice, this leeway
+  // make sense because many scalar will tend to accept only one kind of values (say, strings) and exists only to inform that said string
+  // needs to follow a specific format, and in such case, letting user redefine the type as String adds flexibility while doing little harm.
+  if (isListType(expectedType)) {
+    return isListType(actualType) && isValidInputTypeRedefinition(expectedType.ofType, actualType.ofType);
+  }
+  if (isNonNullType(expectedType)) {
+    return isNonNullType(actualType) && isValidInputTypeRedefinition(expectedType.ofType, actualType.ofType);
+  }
+  return isCustomScalarType(expectedType) && !isCustomScalarType(actualType);
+}

package/src/error.ts

@@ -105,15 +105,53 @@ export function errorCodeDef(e: GraphQLError | string): ErrorCodeDefinition | un
   return code ? codeDefByCode[code] : undefined;
 }
 
+export function withModifiedErrorMessage(e: GraphQLError, newMessage: string): GraphQLError {
+  return new GraphQLError(
+    newMessage,
+    {
+      nodes: e.nodes,
+      source: e.source,
+      positions: e.positions,
+      path: e.path,
+      originalError: e.originalError,
+      extensions: e.extensions
+    }
+  );
+}
+
+export function withModifiedErrorNodes(e: GraphQLError, newNodes: readonly ASTNode[] | ASTNode | undefined): GraphQLError {
+  return new GraphQLError(
+    e.message,
+    {
+      nodes: newNodes,
+      source: e.source,
+      positions: e.positions,
+      path: e.path,
+      originalError: e.originalError,
+      extensions: e.extensions
+    }
+  );
+}
+
 const INVALID_GRAPHQL = makeCodeDefinition(
   'INVALID_GRAPHQL',
   '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 +187,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 +275,16 @@ 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 MERGED_DIRECTIVE_APPLICATION_ON_EXTERNAL = makeCodeDefinition(
+  'MERGED_DIRECTIVE_APPLICATION_ON_EXTERNAL',
+  'In a subgraph, a field is both marked @external and has a merged directive applied to it',
+);
+
 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 +307,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,11 +329,71 @@ 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 LINK_IMPORT_NAME_MISMATCH = makeCodeDefinition(
+  'LINK_IMPORT_NAME_MISMATCH',
+  'The import name for a merged directive (as declared by the relevant `@link(import:)` argument) is inconsistent between subgraphs.'
+);
+
+const REFERENCED_INACCESSIBLE = makeCodeDefinition(
+  'REFERENCED_INACCESSIBLE',
+  'An element is marked as @inaccessible but is referenced by a non-inaccessible element.'
+);
+
+const REQUIRED_INPUT_FIELD_MISSING_IN_SOME_SUBGRAPH = makeCodeDefinition(
+  'REQUIRED_INPUT_FIELD_MISSING_IN_SOME_SUBGRAPH',
+  'A field of an input object type is mandatory in some subgraphs, but the field is not defined in all the subgraphs that define the input object type.'
+);
+
+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 the subgraphs that define the field or directive definition.'
+);
+
+const EMPTY_MERGED_INPUT_TYPE = makeCodeDefinition(
+  'EMPTY_MERGED_INPUT_TYPE',
+  'An input object type has no field common to all the subgraphs that define the type. Merging that type would result in an invalid empty input object type.'
+);
+
+const INCONSISTENT_ENUM_VALUE = makeCodeDefinition(
+  'INCONSISTENT_ENUM_VALUE',
+  'An enum type that is used as both an input and output type has a value that is not defined in all the subgraphs that define the enum type.'
+);
+
+const EMPTY_MERGED_ENUM_TYPE = makeCodeDefinition(
+  'EMPTY_MERGED_ENUM_TYPE',
+  'An enum type has no value common to all the subgraphs that define the type. Merging that type would result in an invalid empty enum type.'
+);
+
 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.',
 );
 
+const OVERRIDE_FROM_SELF_ERROR = makeCodeDefinition(
+  'OVERRIDE_FROM_SELF_ERROR',
+  'Field with `@override` directive has "from" location that references its own subgraph.',
+);
+
+const OVERRIDE_SOURCE_HAS_OVERRIDE = makeCodeDefinition(
+  'OVERRIDE_SOURCE_HAS_OVERRIDE',
+  'Field which is overridden to another subgraph is also marked @override.',
+);
+
+const OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE = makeCodeDefinition(
+  'OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE',
+  'The @override directive cannot be used on external fields, nor to override fields with either @external, @provides, or @requires.',
+);
+
 export const ERROR_CATEGORIES = {
   DIRECTIVE_FIELDS_MISSING_EXTERNAL,
   DIRECTIVE_UNSUPPORTED_ON_INTERFACE,
@@ -285,7 +405,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 +417,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,14 +437,29 @@ export const ERRORS = {
   EXTERNAL_ARGUMENT_MISSING,
   EXTERNAL_ARGUMENT_TYPE_MISMATCH,
   EXTERNAL_ARGUMENT_DEFAULT_MISMATCH,
+  EXTERNAL_ON_INTERFACE,
+  MERGED_DIRECTIVE_APPLICATION_ON_EXTERNAL,
   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,
+  LINK_IMPORT_NAME_MISMATCH,
+  REFERENCED_INACCESSIBLE,
+  REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH,
+  REQUIRED_INPUT_FIELD_MISSING_IN_SOME_SUBGRAPH,
+  EMPTY_MERGED_INPUT_TYPE,
+  INCONSISTENT_ENUM_VALUE,
+  EMPTY_MERGED_ENUM_TYPE,
   SATISFIABILITY_ERROR,
+  OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE,
+  OVERRIDE_FROM_SELF_ERROR,
+  OVERRIDE_SOURCE_HAS_OVERRIDE,
 };
 
 const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorCodeDefinition}, codeDef: ErrorCodeDefinition) => { obj[codeDef.code] = codeDef; return obj; }, {});