@apollo/federation-internals 2.0.0-preview.8 → 2.0.1

package/src/directiveAndTypeSpecification.ts

@@ -1,8 +1,12 @@
-import { DirectiveLocation, GraphQLError } from "graphql";
+import { ASTNode, DirectiveLocation, GraphQLError } from "graphql";
 import {
   ArgumentDefinition,
   DirectiveDefinition,
+  EnumType,
   InputType,
+  isCustomScalarType,
+  isEnumType,
+  isListType,
   isNonNullType,
   isObjectType,
   isUnionType,
@@ -49,13 +53,16 @@ export function createDirectiveSpecification({
   name: string,
   locations: DirectiveLocation[],
   repeatable?: boolean,
-  argumentFct?: (schema: Schema) => ArgumentSpecification[],
+  argumentFct?: (schema: Schema, nameInSchema?: string) => { args: ArgumentSpecification[], errors: GraphQLError[] },
 }): DirectiveSpecification {
   return {
     name,
     checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const args = argumentFct ? argumentFct(schema) : [];
       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);
@@ -131,7 +138,7 @@ export function createObjectTypeSpecification({
           errors = errors.concat(ensureSameArguments(
             { name, args },
             existingField,
-            `field ${existingField.coordinate}`,
+            `field "${existingField.coordinate}"`,
           ));
         }
         return errors;
@@ -198,6 +205,44 @@ export function createUnionTypeSpecification({
   }
 }
 
+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
     ? []
@@ -216,18 +261,19 @@ function ensureSameDirectiveStructure(
   },
   actual: DirectiveDefinition<any>,
 ): GraphQLError[] {
-  let errors = ensureSameArguments(expected, actual, `directive ${expected}`);
+  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 ${expected}: ${expected} should${expected.repeatable ? "" : " not"} be repeatable`,
+      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 efinition for directive ${expected}: ${expected} should have locations ${expected.locations.join(', ')}, but found (non-subset) ${actual.locations.join(', ')}`,
+      message: `Invalid definition for directive ${directiveName}: ${directiveName} should have locations ${expected.locations.join(', ')}, but found (non-subset) ${actual.locations.join(', ')}`,
       nodes: actual.sourceAST
     }));
   }
@@ -241,17 +287,24 @@ function ensureSameArguments(
   },
   actual: { argument(name: string): ArgumentDefinition<any> | undefined, arguments(): readonly ArgumentDefinition<any>[] },
   what: string,
+  containerSourceAST?: ASTNode,
 ): GraphQLError[] {
   const expectedArguments = expected.args ?? [];
-  const foundArguments = actual.arguments();
-  if (expectedArguments.length !== foundArguments.length) {
-    return [ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-      message: `Invalid definition for ${what}: should have ${expectedArguments.length} arguments but ${foundArguments.length} found`,
-    })];
-  }
-  let errors: GraphQLError[] = [];
+  const errors: GraphQLError[] = [];
   for (const { name, type, defaultValue } of expectedArguments) {
-    const actualArgument = actual.argument(name)!;
+    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
@@ -259,14 +312,23 @@ function ensureSameArguments(
       // is optional if you so wish.
       actualType = actualType.ofType;
     }
-    if (!sameType(type, actualType)) {
-      errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-        message: `Invalid definition of ${what}: ${name} should have type ${type} but found type ${actualArgument.type!}`,
+    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
       }));
-    } else if (!isNonNullType(actualType) && !valueEquals(defaultValue, actualArgument.defaultValue)) {
-      errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-        message: `Invalid definition of ${what}: ${name} should have default value ${valueToString(defaultValue)} but found default value ${valueToString(actualArgument.defaultValue)}`,
+    }
+  }
+  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
       }));
     }
@@ -274,3 +336,18 @@ function ensureSameArguments(
   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

@@ -346,12 +346,62 @@ const LINK_IMPORT_NAME_MISMATCH = makeCodeDefinition(
 
 const REFERENCED_INACCESSIBLE = makeCodeDefinition(
   'REFERENCED_INACCESSIBLE',
-  'An element is marked as @inaccessible but is referenced by a non-inaccessible element.'
+  'An element is marked as @inaccessible but is referenced by an element visible in the API schema.'
+);
+
+const DEFAULT_VALUE_USES_INACCESSIBLE = makeCodeDefinition(
+  'DEFAULT_VALUE_USES_INACCESSIBLE',
+  'An element is marked as @inaccessible but is used in the default value of an element visible in the API schema.'
+);
+
+const QUERY_ROOT_TYPE_INACCESSIBLE = makeCodeDefinition(
+  'QUERY_ROOT_TYPE_INACCESSIBLE',
+  'An element is marked as @inaccessible but is the query root type, which must be visible in the API schema.'
+);
+
+const REQUIRED_INACCESSIBLE = makeCodeDefinition(
+  'REQUIRED_INACCESSIBLE',
+  'An element is marked as @inaccessible but is required by an element visible in the API schema.'
+);
+
+const IMPLEMENTED_BY_INACCESSIBLE = makeCodeDefinition(
+  'IMPLEMENTED_BY_INACCESSIBLE',
+  'An element is marked as @inaccessible but implements an element visible in the API schema.'
+);
+
+const DISALLOWED_INACCESSIBLE = makeCodeDefinition(
+  'DISALLOWED_INACCESSIBLE',
+  'An element is marked as @inaccessible that is not allowed to be @inaccessible.'
+);
+
+const ONLY_INACCESSIBLE_CHILDREN = makeCodeDefinition(
+  'ONLY_INACCESSIBLE_CHILDREN',
+  'A type visible in the API schema has only @inaccessible children.'
+);
+
+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 subgraphs that define the field or directive definition.'
+  '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 ENUM_VALUE_MISMATCH = makeCodeDefinition(
+  'ENUM_VALUE_MISMATCH',
+  '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(
@@ -359,6 +409,21 @@ const SATISFIABILITY_ERROR = makeCodeDefinition(
   '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,
@@ -416,8 +481,21 @@ export const ERRORS = {
   INVALID_LINK_DIRECTIVE_USAGE,
   LINK_IMPORT_NAME_MISMATCH,
   REFERENCED_INACCESSIBLE,
+  DEFAULT_VALUE_USES_INACCESSIBLE,
+  QUERY_ROOT_TYPE_INACCESSIBLE,
+  REQUIRED_INACCESSIBLE,
+  DISALLOWED_INACCESSIBLE,
+  IMPLEMENTED_BY_INACCESSIBLE,
+  ONLY_INACCESSIBLE_CHILDREN,
   REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH,
+  REQUIRED_INPUT_FIELD_MISSING_IN_SOME_SUBGRAPH,
+  EMPTY_MERGED_INPUT_TYPE,
+  ENUM_VALUE_MISMATCH,
+  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; }, {});

package/src/extractSubgraphsFromSupergraph.ts

@@ -181,6 +181,12 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
               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});
+              }
             }
           }
         }
@@ -262,7 +268,7 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     // 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.types<InterfaceType>('InterfaceType')) {
+      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()) {