@apollo/federation-internals 2.2.2 → 2.3.0-alpha.0

package/src/__tests__/schemaUpgrader.test.ts

@@ -202,3 +202,46 @@ test('remove tag on external field if found on definition', () => {
   expect(typeAInS1.field("y")?.appliedDirectivesOf('tag').map((d) => d.toString())).toStrictEqual([]);
   expect(typeAInS2.field("y")?.appliedDirectivesOf('tag').map((d) => d.toString())).toStrictEqual([ '@tag(name: "a tag")' ]);
 })
+
+test('reject @interfaceObject usage if not all subgraphs are fed2', () => {
+  // Note that this test both validates the rejection of fed1 subgraph when @interfaceObject is used somewhere, but also
+  // illustrate why we do so: fed1 schema can use @key on interface for backward compatibility, but it is ignored and
+  // the schema upgrader removes them. Given that actual support for @key on interfaces is necesarry to make @interfaceObject
+  // work, it would be really confusing to not reject the example below right away, since it "looks" like it the @key on
+  // the interface in the 2nd subgraph should work, but it actually won't.
+
+  const s1 = `
+    extend schema
+      @link(url: "https://specs.apollo.dev/federation/v2.3", import: [ "@key", "@interfaceObject"])
+
+    type Query {
+      a: A
+    }
+
+    type A @key(fields: "id") @interfaceObject {
+      id: String
+      x: Int
+    }
+  `;
+
+  const s2 = `
+    interface A @key(fields: "id") {
+      id: String
+      y: Int
+    }
+
+    type X implements A @key(fields: "id") {
+      id: String
+      y: Int
+    }
+  `;
+
+  const subgraphs = new Subgraphs();
+  subgraphs.add(buildSubgraph('s1', 'http://s1', s1));
+  subgraphs.add(buildSubgraph('s2', 'http://s2', s2));
+  const res = upgradeSubgraphsIfNecessary(subgraphs);
+  expect(res.errors?.map((e) => e.message)).toStrictEqual([
+    'The @interfaceObject directive can only be used if all subgraphs have federation 2 subgraph schema (schema with a `@link` to "https://specs.apollo.dev/federation" version 2.0 or newer): '
+    + '@interfaceObject is used in subgraph "s1" but subgraph "s2" is not a federation 2 subgraph schema.'
+  ]);
+})

package/src/__tests__/subgraphValidation.test.ts

@@ -1,33 +1,9 @@
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
-import { Subgraph, errorCauses } from '..';
-import { asFed2SubgraphDocument, buildSubgraph } from "../federation"
+import { Subgraph } from '..';
+import { buildSubgraph } from "../federation"
 import { defaultPrintOptions, printSchema } from '../print';
-import './matchers';
-
-// Builds the provided subgraph (using name 'S' for the subgraph) and, if the
-// subgraph is invalid/has errors, return those errors as a list of [code, message].
-// If the subgraph is valid, return undefined.
-export function buildForErrors(
-  subgraphDefs: DocumentNode,
-  options?: {
-    subgraphName?: string,
-    asFed2?: boolean,
-  }
-): [string, string][] | undefined {
-  try {
-    const doc = (options?.asFed2 ?? true) ? asFed2SubgraphDocument(subgraphDefs) : subgraphDefs;
-    const name = options?.subgraphName ?? 'S';
-    buildSubgraph(name, `http://${name}`, doc).validate();
-    return undefined;
-  } catch (e) {
-    const causes = errorCauses(e);
-    if (!causes) {
-      throw e;
-    }
-    return causes.map((err) => [err.extensions.code as string, err.message]);
-  }
-}
+import { buildForErrors } from './testUtils';
 
 describe('fieldset-based directives', () => {
   it('rejects field defined with arguments in @key', () => {
@@ -91,8 +67,11 @@ describe('fieldset-based directives', () => {
     ]);
   });
 
-  it('rejects @key on interfaces', () => {
+  it.each(['2.0', '2.1', '2.2'])('rejects @key on interfaces _in the %p spec_', (version) => {
     const subgraph =  gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v${version}", import: ["@key"])
+
       type Query {
         t: T
       }
@@ -101,7 +80,7 @@ describe('fieldset-based directives', () => {
         f: Int
       }
     `
-    expect(buildForErrors(subgraph)).toStrictEqual([
+    expect(buildForErrors(subgraph, { asFed2: false })).toStrictEqual([
       ['KEY_UNSUPPORTED_ON_INTERFACE', '[S] Cannot use @key on interface "T": @key is not yet supported on interfaces'],
     ]);
   });
@@ -559,34 +538,6 @@ describe('root types', () => {
   });
 });
 
-it('validates all implementations of interface field have same type if any has @external', () => {
-  const subgraph = gql`
-    type Query {
-      is: [I!]!
-    }
-
-    interface I {
-      f: Int
-    }
-
-    type T1 implements I {
-      f: Int
-    }
-
-    type T2 implements I {
-      f: Int!
-    }
-
-    type T3 implements I {
-      id: ID!
-      f: Int @external
-    }
-  `;
-    expect(buildForErrors(subgraph)).toStrictEqual([
-      ['INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH', '[S] Some of the runtime implementations of interface field "I.f" are marked @external or have a @require ("T3.f") so all the implementations should use the same type (a current limitation of federation; see https://github.com/apollographql/federation/issues/1257), but "T1.f" and "T3.f" have type "Int" while "T2.f" has type "Int!".'],
-    ]);
-})
-
 describe('custom error message for misnamed directives', () => {
   it.each([
     { name: 'fed1', extraMsg: ' If so, note that it is a federation 2 directive but this schema is a federation 1 one. To be a federation 2 schema, it needs to @link to the federation specifcation v2.' },
@@ -1183,3 +1134,121 @@ describe('@shareable', () => {
     ]]);
   });
 });
+
+describe('@interfaceObject/@key on interfaces validation', () => {
+  it('@key on interfaces require @key on all implementations', () => {
+    const doc = gql`
+      interface I @key(fields: "id1") @key(fields: "id2") {
+        id1: ID!
+        id2: ID!
+      }
+
+      type A implements I @key(fields: "id2") {
+        id1: ID!
+        id2: ID!
+        a: Int
+      }
+
+      type B implements I @key(fields: "id1") @key(fields: "id2") {
+        id1: ID!
+        id2: ID!
+        b: Int
+      }
+
+      type C implements I @key(fields: "id2") {
+        id1: ID!
+        id2: ID!
+        c: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INTERFACE_KEY_NOT_ON_IMPLEMENTATION',
+      '[S] Key @key(fields: "id1") on interface type "I" is missing on implementation types "A" and "C".',
+    ]]);
+  });
+
+  it('@key on interfaces with @key on some implementation non resolvable', () => {
+    const doc = gql`
+      interface I @key(fields: "id1") {
+        id1: ID!
+      }
+
+      type A implements I @key(fields: "id1") {
+        id1: ID!
+        a: Int
+      }
+
+      type B implements I @key(fields: "id1") {
+        id1: ID!
+        b: Int
+      }
+
+      type C implements I @key(fields: "id1", resolvable: false) {
+        id1: ID!
+        c: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INTERFACE_KEY_NOT_ON_IMPLEMENTATION',
+      '[S] Key @key(fields: "id1") on interface type "I" should be resolvable on all implementation types, but is declared with argument "@key(resolvable:)" set to false in type "C".',
+    ]]);
+  });
+
+  it('ensures order of fields in key does not matter', () => {
+    const doc = gql`
+      interface I @key(fields: "a b c") {
+        a: Int
+        b: Int
+        c: Int
+      }
+
+      type A implements I @key(fields: "c b a") {
+        a: Int
+        b: Int
+        c: Int
+      }
+
+      type B implements I @key(fields: "a c b") {
+        a: Int
+        b: Int
+        c: Int
+      }
+
+      type C implements I @key(fields: "a b c") {
+        a: Int
+        b: Int
+        c: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  // There is no meaningful way to make @interfaceObject work on a value type at the moment, because
+  // if you have an @interfaceObject, some other subgraph needs to be able to resolve the concrete
+  // type, and that imply that you have key to go to that other subgraph.
+  // To be clear, the @key on the @interfaceObject technically con't need to be "resolvable", and the
+  // difference between no key and a non-resolvable key is arguably more convention than a genuine 
+  // mechanical difference at the moment, but still a good idea to rely on that convention to help
+  // catching obvious mistakes early.
+  it('only allow @interfaceObject on entity types', () => {
+    const doc = gql`
+      # This one shouldn't raise an error
+      type A @key(fields: "id", resolvable: false) @interfaceObject {
+        id: ID!
+      }
+
+      # This one should
+      type B @interfaceObject {
+        x: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INTERFACE_OBJECT_USAGE_ERROR',
+      '[S] The @interfaceObject directive can only be applied to entity types but type "B" has no @key in this subgraph.'
+    ]]);
+  });
+});

package/src/__tests__/testUtils.ts

@@ -0,0 +1,28 @@
+import { DocumentNode } from "graphql";
+import { asFed2SubgraphDocument, buildSubgraph, errorCauses } from "..";
+import './matchers';
+
+// Builds the provided subgraph (using name 'S' for the subgraph) and, if the
+// subgraph is invalid/has errors, return those errors as a list of [code, message].
+// If the subgraph is valid, return undefined.
+export function buildForErrors(
+  subgraphDefs: DocumentNode,
+  options?: {
+    subgraphName?: string,
+    asFed2?: boolean,
+  }
+): [string, string][] | undefined {
+  try {
+    const doc = (options?.asFed2 ?? true) ? asFed2SubgraphDocument(subgraphDefs) : subgraphDefs;
+    const name = options?.subgraphName ?? 'S';
+    buildSubgraph(name, `http://${name}`, doc).validate();
+    return undefined;
+  } catch (e) {
+    const causes = errorCauses(e);
+    if (!causes) {
+      throw e;
+    }
+    return causes.map((err) => [err.extensions.code as string, err.message]);
+  }
+}
+

package/src/__tests__/values.test.ts

@@ -3,10 +3,10 @@ import {
 } from '../definitions';
 import { buildSchema } from '../buildSchema';
 import { parseOperation } from '../operations';
-import { buildForErrors } from './subgraphValidation.test';
 import gql from 'graphql-tag';
 import { printSchema } from '../print';
 import { valueEquals } from '../values';
+import { buildForErrors } from './testUtils';
 
 function parseSchema(schema: string): Schema {
   try {

package/src/definitions.ts

@@ -241,6 +241,14 @@ export function runtimeTypesIntersects(t1: CompositeType, t2: CompositeType): bo
   return false;
 }
 
+export function supertypes(type: CompositeType): readonly CompositeType[] {
+  switch (type.kind) {
+    case 'InterfaceType': return type.interfaces();
+    case 'UnionType': return [];
+    case 'ObjectType': return (type.interfaces() as CompositeType[]).concat(type.unionsWhereMember());
+  }
+}
+
 export function isConditionalDirective(directive: Directive<any, any> | DirectiveDefinition<any>): boolean {
   return ['include', 'skip'].includes(directive.name);
 }
@@ -2098,6 +2106,10 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
         break;
     }
   }
+
+  unionsWhereMember(): readonly UnionType[] {
+    return this._referencers?.filter<UnionType>((r): r is UnionType => r instanceof BaseNamedType && isUnionType(r)) ?? [];
+  }
 }
 
 export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeReferencer> {

package/src/error.ts

@@ -235,7 +235,7 @@ const REQUIRES_MISSING_EXTERNAL = DIRECTIVE_FIELDS_MISSING_EXTERNAL.createCode('
 
 const DIRECTIVE_UNSUPPORTED_ON_INTERFACE = makeFederationDirectiveErrorCodeCategory(
   'UNSUPPORTED_ON_INTERFACE',
-  (directive) => `A \`@${directive}\` directive is used on an interface, which is not (yet) supported.`,
+  (directive) => `A \`@${directive}\` directive is used on an interface, which is ${directive === 'key' ? 'only supported when @linking to federation 2.3+' : 'not (yet) supported'}.`,
 );
 
 const KEY_UNSUPPORTED_ON_INTERFACE = DIRECTIVE_UNSUPPORTED_ON_INTERFACE.createCode('key');
@@ -395,11 +395,6 @@ const EXTERNAL_MISSING_ON_BASE = makeCodeDefinition(
   { addedIn: FED1_CODE },
 );
 
-const INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH = makeCodeDefinition(
-  'INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH',
-  '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.'
@@ -531,6 +526,25 @@ const DIRECTIVE_COMPOSITION_ERROR = makeCodeDefinition(
   { addedIn: '2.1.0' },
 );
 
+const INTERFACE_OBJECT_USAGE_ERROR = makeCodeDefinition(
+  'INTERFACE_OBJECT_USAGE_ERROR',
+  'Error in the usage of the @interfaceObject directive.',
+  { addedIn: '2.3.0' },
+);
+
+const INTERFACE_KEY_NOT_ON_IMPLEMENTATION = makeCodeDefinition(
+  'INTERFACE_KEY_NOT_ON_IMPLEMENTATION',
+  'A `@key` is defined on an interface type, but is not defined (or is not resolvable) on at least one of the interface implementations',
+  { addedIn: '2.3.0' },
+);
+
+const INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE = makeCodeDefinition(
+  'INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE',
+  'A subgraph has a `@key` on an interface type, but that subgraph does not define an implementation (in the supergraph) of that interface',
+  { addedIn: '2.3.0' },
+)
+
+
 export const ERROR_CATEGORIES = {
   DIRECTIVE_FIELDS_MISSING_EXTERNAL,
   DIRECTIVE_UNSUPPORTED_ON_INTERFACE,
@@ -585,7 +599,6 @@ export const ERRORS = {
   ARGUMENT_DEFAULT_MISMATCH,
   EXTENSION_WITH_NO_BASE,
   EXTERNAL_MISSING_ON_BASE,
-  INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH,
   INVALID_FIELD_SHARING,
   INVALID_SHAREABLE_USAGE,
   INVALID_LINK_DIRECTIVE_USAGE,
@@ -614,6 +627,9 @@ export const ERRORS = {
   PROVIDES_HAS_DIRECTIVE_IN_FIELDS_ARGS,
   REQUIRES_HAS_DIRECTIVE_IN_FIELDS_ARGS,
   DIRECTIVE_COMPOSITION_ERROR,
+  INTERFACE_OBJECT_USAGE_ERROR,
+  INTERFACE_KEY_NOT_ON_IMPLEMENTATION,
+  INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE,
 };
 
 const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorCodeDefinition}, codeDef: ErrorCodeDefinition) => { obj[codeDef.code] = codeDef; return obj; }, {});
@@ -638,16 +654,18 @@ export const REMOVED_ERRORS = [
   ['REQUIRES_FIELDS_MISSING_ON_BASE', 'Fields in @requires can now be from any subgraph.'],
   ['REQUIRES_USED_ON_BASE', 'As there is not type ownership anymore, there is also no particular limitation as to which subgraph can use a @requires.'],
 
-  ['DUPLICATE_SCALAR_DEFINITION', 'As duplicate scalar definitions is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`'],
-  ['DUPLICATE_ENUM_DEFINITION', 'As duplicate enum definitions is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`'],
-  ['DUPLICATE_ENUM_VALUE', 'As duplicate enum values is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`'],
+  ['DUPLICATE_SCALAR_DEFINITION', 'As duplicate scalar definitions is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`.'],
+  ['DUPLICATE_ENUM_DEFINITION', 'As duplicate enum definitions is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`.'],
+  ['DUPLICATE_ENUM_VALUE', 'As duplicate enum values is invalid GraphQL, this will now be an error with code `INVALID_GRAPHQL`.'],
 
-  ['ENUM_MISMATCH', 'Subgraph definitions for an enum are now merged by composition'],
+  ['ENUM_MISMATCH', 'Subgraph definitions for an enum are now merged by composition.'],
   ['VALUE_TYPE_NO_ENTITY', 'There is no strong different between entity and value types in the model (they are just usage pattern) and a type can have keys in one subgraph but not another.'],
-  ['VALUE_TYPE_UNION_TYPES_MISMATCH', 'Subgraph definitions for an union are now merged by composition'],
-  ['PROVIDES_FIELDS_SELECT_INVALID_TYPE', '@provides can now be used on field of interface, union and list types'],
-  ['RESERVED_FIELD_USED', 'This error was previously not correctly enforced: the _service and _entities, if present, were overridden; this is still the case'],
+  ['VALUE_TYPE_UNION_TYPES_MISMATCH', 'Subgraph definitions for an union are now merged by composition.'],
+  ['PROVIDES_FIELDS_SELECT_INVALID_TYPE', '@provides can now be used on field of interface, union and list types.'],
+  ['RESERVED_FIELD_USED', 'This error was previously not correctly enforced: the _service and _entities, if present, were overridden; this is still the case.'],
+
+  ['NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH', 'Since federation 2.1.0, the case this error used to cover is now a warning (with code `INCONSISTENT_NON_REPEATABLE_DIRECTIVE_ARGUMENTS`) instead of an error.'],
+  ['REQUIRES_FIELDS_HAS_ARGS', 'Since federation 2.1.1, using fields with arguments in a @requires is fully supported.'],
 
-  ['NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH', 'Since federation 2.1.0, the case this error used to cover is now a warning (with code `INCONSISTENT_NON_REPEATABLE_DIRECTIVE_ARGUMENTS`) instead of an error'],
-  ['REQUIRES_FIELDS_HAS_ARGS', 'Since federation 2.1.1, using fields with arguments in a @requires is fully supported'],
+  ['INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH', 'This error was thrown by a validation introduced to avoid running into a known runtime bug. Since federation 2.3, the underlying runtime bug has been addressed and the validation/limitation was no longer necessary and has been removed.'],
 ];

package/src/extractSubgraphsFromSupergraph.ts

@@ -201,8 +201,13 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     const implementsDirective = joinSpec.implementsDirective(supergraph);
     const ownerDirective = joinSpec.ownerDirective(supergraph);
     const fieldDirective = joinSpec.fieldDirective(supergraph);
+    const unionMemberDirective = joinSpec.unionMemberDirective(supergraph);
+    const enumValueDirective = joinSpec.enumValueDirective(supergraph);
 
-    const getSubgraph = (application: Directive<any, { graph: string }>) => graphEnumNameToSubgraphName.get(application.arguments().graph);
+    const getSubgraph = (application: Directive<any, { graph?: string }>) => {
+      const graph = application.arguments().graph;
+      return graph ? graphEnumNameToSubgraphName.get(graph) : undefined;
+    };
 
     /*
      * Fed2 supergraph have "provenance" information for all types and fields, so we can faithfully extract subgraph relatively easily.
@@ -221,7 +226,7 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
         supergraph,
         subgraphs.names(),
         (f, name) => {
-          const fieldApplications: Directive<any, { graph: string, requires?: string, provides?: string }>[] = f.appliedDirectivesOf(fieldDirective);
+          const fieldApplications: Directive<any, { graph?: string, requires?: string, provides?: string }>[] = f.appliedDirectivesOf(fieldDirective);
           if (fieldApplications.length) {
             const application = fieldApplications.find((application) => getSubgraph(application) === name);
             if (application) {
@@ -274,7 +279,11 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
           // We can have more than one type directive for a given subgraph
           let subgraphType = schema.type(type.name);
           if (!subgraphType) {
-            subgraphType = schema.addType(newNamedType(type.kind, type.name));
+            const kind = args.isInterfaceObject ? 'ObjectType' : type.kind;
+            subgraphType = schema.addType(newNamedType(kind, type.name));
+            if (args.isInterfaceObject) {
+              subgraphType.applyDirective('interfaceObject');
+            }
           }
           if (args.key) {
             const { resolvable } = args;
@@ -353,6 +362,11 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
 
               for (const application of fieldApplications) {
                 const args = application.arguments();
+                // We use a @join__field with no graph to indicates when a field in the supergraph does not come
+                // directly from any subgraph and there is thus nothing to do to "extract" it.
+                if (!args.graph) {
+                  continue;
+                }
                 const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
                 const subgraphField = addSubgraphField(field, subgraph, args.type);
                 if (!subgraphField) {
@@ -394,23 +408,40 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
               continue;
             }
             assert(isEnumType(subgraphEnum), () => `${subgraphEnum} should be an enum but found a ${subgraphEnum.kind}`);
+
             for (const value of type.values) {
-              subgraphEnum.addValue(value.name);
+              // Before version 0.3 of the join spec (before `enumValueDirective`), we were not recording which subgraph defined which values,
+              // and instead aded all values to all subgraphs (at least if the type existed there).
+              const addValue = !enumValueDirective
+                || value.appliedDirectivesOf(enumValueDirective).some((d) =>
+                  graphEnumNameToSubgraphName.get(d.arguments().graph) === subgraph.name
+                );
+              if (addValue) {
+                subgraphEnum.addValue(value.name);
+              }
             }
           }
           break;
         case 'UnionType':
-          // TODO: Same as for enums. We need to know in which subgraph each member is defined.
-          // But for now, we also add every members to all subgraphs (as long as the subgraph has both the union type
-          // and the member in question).
           for (const subgraph of subgraphs) {
             const subgraphUnion = subgraph.schema.type(type.name);
             if (!subgraphUnion) {
               continue;
             }
             assert(isUnionType(subgraphUnion), () => `${subgraphUnion} should be an enum but found a ${subgraphUnion.kind}`);
-            for (const memberType of type.types()) {
-              const subgraphType = subgraph.schema.type(memberType.name);
+            let membersInSubgraph: string[];
+            if (unionMemberDirective) {
+              membersInSubgraph = type
+                .appliedDirectivesOf(unionMemberDirective)
+                .filter((d) => graphEnumNameToSubgraphName.get(d.arguments().graph) === subgraph.name)
+                .map((d) => d.arguments().member);
+            } else {
+              // Before version 0.3 of the join spec, we were not recording which subgraph defined which members,
+              // and instead aded all members to all subgraphs (at least if the type existed there).
+              membersInSubgraph = type.types().map((t) => t.name);
+            }
+            for (const memberTypeName of membersInSubgraph) {
+              const subgraphType = subgraph.schema.type(memberTypeName);
               if (subgraphType) {
                 subgraphUnion.addType(subgraphType as ObjectType);
               }