@apollo/federation-internals 2.2.3 → 2.3.0-beta.1

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.'
@@ -487,6 +482,11 @@ const EMPTY_MERGED_ENUM_TYPE = makeCodeDefinition(
   '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 SHAREABLE_HAS_MISMATCHED_RUNTIME_TYPES = makeCodeDefinition(
+  'SHAREABLE_HAS_MISMATCHED_RUNTIME_TYPES',
+  'A shareable field return type has mismatched possible runtime types in the subgraphs in which the field is declared. As shared fields must resolve the same way in all subgraphs, this is almost surely a mistake.'
+);
+
 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.',
@@ -507,6 +507,12 @@ const OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE = makeCodeDefinition(
   'The @override directive cannot be used on external fields, nor to override fields with either @external, @provides, or @requires.',
 );
 
+const OVERRIDE_ON_INTERFACE = makeCodeDefinition(
+  'OVERRIDE_ON_INTERFACE',
+  'The @override directive cannot be used on the fields of an interface type.',
+  { addedIn: '2.3.0' },
+);
+
 const UNSUPPORTED_FEATURE = makeCodeDefinition(
   'UNSUPPORTED_FEATURE',
   'Indicates an error due to feature currently unsupported by federation.',
@@ -531,6 +537,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 +610,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,
@@ -603,10 +627,12 @@ export const ERRORS = {
   EMPTY_MERGED_INPUT_TYPE,
   ENUM_VALUE_MISMATCH,
   EMPTY_MERGED_ENUM_TYPE,
+  SHAREABLE_HAS_MISMATCHED_RUNTIME_TYPES,
   SATISFIABILITY_ERROR,
   OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE,
   OVERRIDE_FROM_SELF_ERROR,
   OVERRIDE_SOURCE_HAS_OVERRIDE,
+  OVERRIDE_ON_INTERFACE,
   UNSUPPORTED_FEATURE,
   INVALID_FEDERATION_SUPERGRAPH,
   DOWNSTREAM_SERVICE_ERROR,
@@ -614,6 +640,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 +667,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);
               }