@apollo/federation-internals 2.7.1 → 2.7.3-testing.0

package/src/operations.ts

@@ -48,6 +48,8 @@ import {
   isObjectType,
   NamedType,
   isUnionType,
+  directivesToString,
+  directivesToDirectiveNodes,
 } from "./definitions";
 import { isInterfaceObjectType } from "./federation";
 import { ERRORS } from "./error";
@@ -877,7 +879,6 @@ function computeFragmentsToKeep(
   return toExpand.size === 0 ? fragments : fragments.filter((f) => !toExpand.has(f.name));
 }
 
-// TODO Operations can also have directives
 export class Operation {
   constructor(
     readonly schema: Schema,
@@ -885,7 +886,8 @@ export class Operation {
     readonly selectionSet: SelectionSet,
     readonly variableDefinitions: VariableDefinitions,
     readonly fragments?: NamedFragments,
-    readonly name?: string) {
+    readonly name?: string,
+    readonly directives?: readonly Directive<any>[]) {
   }
 
   // Returns a copy of this operation with the provided updated selection set.
@@ -901,7 +903,8 @@ export class Operation {
       newSelectionSet,
       this.variableDefinitions,
       this.fragments,
-      this.name
+      this.name,
+      this.directives
     );
   }
 
@@ -917,7 +920,8 @@ export class Operation {
       newSelectionSet,
       this.variableDefinitions,
       newFragments,
-      this.name
+      this.name,
+      this.directives
     );
   }
 
@@ -973,6 +977,19 @@ export class Operation {
     return this.withUpdatedSelectionSetAndFragments(optimizedSelection, finalFragments ?? undefined);
   }
 
+  generateQueryFragments(): Operation {
+    const [minimizedSelectionSet, fragments] = this.selectionSet.minimizeSelectionSet();
+    return new Operation(
+      this.schema,
+      this.rootKind,
+      minimizedSelectionSet,
+      this.variableDefinitions,
+      fragments,
+      this.name,
+      this.directives
+    );
+  }
+
   expandAllFragments(): Operation {
     // We clear up the fragments since we've expanded all.
     // Also note that expanding fragment usually generate unecessary fragments/inefficient selections, so it
@@ -1041,7 +1058,7 @@ export class Operation {
   }
 
   toString(expandFragments: boolean = false, prettyPrint: boolean = true): string {
-    return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.fragments, this.name, expandFragments, prettyPrint);
+    return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.fragments, this.name, this.directives, expandFragments, prettyPrint);
   }
 }
 
@@ -1207,6 +1224,14 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
     const expandedSelectionSet = this.expandedSelectionSet();
     const selectionSet = expandedSelectionSet.normalize({ parentType: type });
 
+    if (!isObjectType(this.typeCondition)) {
+      // When the type condition of the fragment is not an object type, the `FieldsInSetCanMerge` rule is more
+      // restrictive and any fields can create conflicts. Thus, we have to use the full validator in this case.
+      // (see https://github.com/graphql/graphql-spec/issues/1085 for details.)
+      const validator = FieldsConflictValidator.build(expandedSelectionSet);
+      return { selectionSet, validator };
+    }
+
     // Note that `trimmed` is the difference of 2 selections that may not have been normalized on the same parent type,
     // so in practice, it is possible that `trimmed` contains some of the selections that `selectionSet` contains, but
     // that they have been simplified in `selectionSet` in such a way that the `minus` call does not see it. However,
@@ -1378,28 +1403,6 @@ export class NamedFragments {
     });
   }
 
-  // When we rebase named fragments on a subgraph schema, only a subset of what the fragment handles may belong
-  // to that particular subgraph. And there are a few sub-cases where that subset is such that we basically need or
-  // want to consider to ignore the fragment for that subgraph, and that is when:
-  // 1. the subset that apply is actually empty. The fragment wouldn't be valid in this case anyway.
-  // 2. the subset is a single leaf field: in that case, using the one field directly is just shorter than using
-  //   the fragment, so we consider the fragment don't really apply to that subgraph. Technically, using the
-  //   fragment could still be of value if the fragment name is a lot smaller than the one field name, but it's
-  //   enough of a niche case that we ignore it. Note in particular that one sub-case of this rule that is likely
-  //   to be common is when the subset ends up being just `__typename`: this would basically mean the fragment
-  //   don't really apply to the subgraph, and that this will ensure this is the case.
-  private selectionSetIsWorthUsing(selectionSet: SelectionSet): boolean {
-    const selections = selectionSet.selections();
-    if (selections.length === 0) {
-      return false;
-    }
-    if (selections.length === 1) {
-      const s = selections[0];
-      return !(s.kind === 'FieldSelection' && s.element.isLeafField());
-    }
-    return true;
-  }
-
   rebaseOn(schema: Schema): NamedFragments | undefined {
     return this.mapInDependencyOrder((fragment, newFragments) => {
       const rebasedType = schema.type(fragment.selectionSet.parentType.name);
@@ -1411,7 +1414,7 @@ export class NamedFragments {
       // Rebasing can leave some inefficiencies in some case (particularly when a spread has to be "expanded", see `FragmentSpreadSelection.rebaseOn`),
       // so we do a top-level normalization to keep things clean.
       rebasedSelection = rebasedSelection.normalize({ parentType: rebasedType });
-      return this.selectionSetIsWorthUsing(rebasedSelection)
+      return rebasedSelection.isWorthUsing()
         ? new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection)
         : undefined;
     });
@@ -1535,6 +1538,60 @@ export class SelectionSet {
     this._selections = mapValues(keyedSelections);
   }
 
+  /**
+   * Takes a selection set and extracts inline fragments into named fragments,
+   * reusing generated named fragments when possible.
+   */
+  minimizeSelectionSet(
+    namedFragments: NamedFragments = new NamedFragments(),
+    seenSelections: Map<string, [SelectionSet, NamedFragmentDefinition][]> = new Map(),
+  ): [SelectionSet, NamedFragments] {
+    const minimizedSelectionSet = this.lazyMap((selection) => {
+      if (selection.kind === 'FragmentSelection' && selection.element.typeCondition && selection.element.appliedDirectives.length === 0
+          && selection.selectionSet && selection.selectionSet.isWorthUsing() ) {
+        // No proper hash code, so we use a unique enough number that's cheap to
+        // compute and handle collisions as necessary.
+        const mockHashCode = `on${selection.element.typeCondition}` + selection.selectionSet.selections().length;
+        const equivalentSelectionSetCandidates = seenSelections.get(mockHashCode);
+        if (equivalentSelectionSetCandidates) {
+          // See if any candidates have an equivalent selection set, i.e. {x y} and {y x}.
+          const match = equivalentSelectionSetCandidates.find(([candidateSet]) => candidateSet.equals(selection.selectionSet!));
+          if (match) {
+            // If we found a match, we can reuse the fragment (but we still need
+            // to create a new FragmentSpread since parent types may differ).
+            return new FragmentSpreadSelection(this.parentType, namedFragments, match[1], []);
+          }
+        }
+
+        // No match, so we need to create a new fragment. First, we minimize the
+        // selection set before creating the fragment with it.
+        const [minimizedSelectionSet] = selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections);
+        const fragmentDefinition = new NamedFragmentDefinition(
+          this.parentType.schema(),
+          `_generated_${mockHashCode}_${equivalentSelectionSetCandidates?.length ?? 0}`,
+          selection.element.typeCondition
+        ).setSelectionSet(minimizedSelectionSet);
+
+        // Create a new "hash code" bucket or add to the existing one.
+        if (!equivalentSelectionSetCandidates) {
+          seenSelections.set(mockHashCode, [[selection.selectionSet, fragmentDefinition]]);
+          namedFragments.add(fragmentDefinition);
+        } else {
+          equivalentSelectionSetCandidates.push([selection.selectionSet, fragmentDefinition]);
+        }
+
+        return new FragmentSpreadSelection(this.parentType, namedFragments, fragmentDefinition, []);
+      } else if (selection.kind === 'FieldSelection') {
+        if (selection.selectionSet) {
+          selection = selection.withUpdatedSelectionSet(selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections)[0]);
+        }
+      }
+      return selection;
+    });
+
+    return [minimizedSelectionSet, namedFragments];
+  }
+
   selectionsInReverseOrder(): readonly Selection[] {
     const length = this._selections.length;
     const reversed = new Array<Selection>(length);
@@ -2033,6 +2090,7 @@ export class SelectionSet {
     variableDefinitions: VariableDefinitions,
     fragments: NamedFragments | undefined,
     operationName?: string,
+    directives?: readonly Directive<any>[],
     expandFragments: boolean = false,
     prettyPrint: boolean = true
   ): string {
@@ -2046,7 +2104,8 @@ export class SelectionSet {
     const nameAndVariables = operationName
       ? " " + (operationName + (variableDefinitions.isEmpty() ? "" : variableDefinitions.toString()))
       : (variableDefinitions.isEmpty() ? "" : " " + variableDefinitions.toString());
-    return fragmentsDefinitions + rootKind + nameAndVariables + " " + this.toString(expandFragments, true, indent);
+    const directives_str = directivesToString(directives);
+    return fragmentsDefinitions + rootKind + nameAndVariables + directives_str + " " + this.toString(expandFragments, true, indent);
   }
 
   /**
@@ -2077,6 +2136,34 @@ export class SelectionSet {
         : selectionsToString;
     }
   }
+
+  // `isWorthUsing` method is used to determine whether we want to factor out
+  // given selection set into a named fragment so it can be reused across the query.
+  // Currently, it is used in these cases:
+  // 1) to reuse existing named fragments in subgraph queries (when reuseQueryFragments is on)
+  // 2) to factor selection sets into named fragments (when generateQueryFragments is on).
+  //
+  // When we rebase named fragments on a subgraph schema, only a subset of what the fragment handles may belong
+  // to that particular subgraph. And there are a few sub-cases where that subset is such that we basically need or
+  // want to consider to ignore the fragment for that subgraph, and that is when:
+  // 1. the subset that apply is actually empty. The fragment wouldn't be valid in this case anyway.
+  // 2. the subset is a single leaf field: in that case, using the one field directly is just shorter than using
+  //   the fragment, so we consider the fragment don't really apply to that subgraph. Technically, using the
+  //   fragment could still be of value if the fragment name is a lot smaller than the one field name, but it's
+  //   enough of a niche case that we ignore it. Note in particular that one sub-case of this rule that is likely
+  //   to be common is when the subset ends up being just `__typename`: this would basically mean the fragment
+  //   don't really apply to the subgraph, and that this will ensure this is the case.
+  isWorthUsing(): boolean {
+    const selections = this.selections();
+    if (selections.length === 0) {
+      return false;
+    }
+    if (selections.length === 1) {
+      const s = selections[0];
+      return !(s.kind === 'FieldSelection' && s.element.isLeafField());
+    }
+    return true;
+  }
 }
 
 type PathBasedUpdate = { path: OperationPath, selections?: Selection | SelectionSet | readonly Selection[] };
@@ -2801,7 +2888,7 @@ class FieldsConflictValidator {
         continue;
       }
 
-      // We're basically checking [FieldInSetCanMerge](https://spec.graphql.org/draft/#FieldsInSetCanMerge()),
+      // We're basically checking [FieldsInSetCanMerge](https://spec.graphql.org/draft/#FieldsInSetCanMerge()),
       // but from 2 set of fields (`thisFields` and `thatFields`) of the same response that we know individually
       // merge already.
       for (const [thisField, thisValidator] of thisFields.entries()) {
@@ -3490,7 +3577,7 @@ class FragmentSpreadSelection extends FragmentSelection {
 
   key(): string {
     if (!this.computedKey) {
-      this.computedKey = '...' + this.namedFragment.name + (this.spreadDirectives.length === 0 ? '' : ' ' + this.spreadDirectives.join(' '));
+      this.computedKey = '...' + this.namedFragment.name + directivesToString(this.spreadDirectives);
     }
     return this.computedKey;
   }
@@ -3516,18 +3603,7 @@ class FragmentSpreadSelection extends FragmentSelection {
   }
 
   toSelectionNode(): FragmentSpreadNode {
-    const directiveNodes = this.spreadDirectives.length === 0
-      ? undefined
-      : this.spreadDirectives.map(directive => {
-        return {
-          kind: Kind.DIRECTIVE,
-          name: {
-            kind: Kind.NAME,
-            value: directive.name,
-          },
-          arguments: directive.argumentsToAST()
-        } as DirectiveNode;
-      });
+    const directiveNodes = directivesToDirectiveNodes(this.spreadDirectives);
     return {
       kind: Kind.FRAGMENT_SPREAD,
       name: { kind: Kind.NAME, value: this.namedFragment.name },
@@ -3672,9 +3748,7 @@ class FragmentSpreadSelection extends FragmentSelection {
     if (expandFragments) {
       return (indent ?? '') + this.element + ' ' + this.selectionSet.toString(true, true, indent);
     } else {
-      const directives = this.spreadDirectives;
-      const directiveString = directives.length == 0 ? '' : ' ' + directives.join(' ');
-      return (indent ?? '') + '...' + this.namedFragment.name + directiveString;
+      return (indent ?? '') + '...' + this.namedFragment.name + directivesToString(this.spreadDirectives);
     }
   }
 }
@@ -3760,6 +3834,7 @@ export function operationFromDocument(
   }
 ) : Operation {
   let operation: OperationDefinitionNode | undefined;
+  let operation_directives: Directive<any>[] | undefined; // the directives on `operation`
   const operationName = options?.operationName;
   const fragments = new NamedFragments();
   // We do a first pass to collect the operation, and create all named fragment, but without their selection set yet.
@@ -3770,6 +3845,7 @@ export function operationFromDocument(
         validate(!operation || operationName, () => 'Must provide operation name if query contains multiple operations.');
         if (!operationName || (definition.name && definition.name.value === operationName)) {
           operation = definition;
+          operation_directives = directivesOfNodes(schema, definition.directives);
         }
         break;
       case Kind.FRAGMENT_DEFINITION:
@@ -3803,18 +3879,20 @@ export function operationFromDocument(
     }
   });
   fragments.validate(variableDefinitions);
-  return operationFromAST({schema, operation, variableDefinitions, fragments, validateInput: options?.validate});
+  return operationFromAST({schema, operation, operation_directives, variableDefinitions, fragments, validateInput: options?.validate});
 }
 
 function operationFromAST({
   schema,
   operation,
+  operation_directives,
   variableDefinitions,
   fragments,
   validateInput,
 }:{
   schema: Schema,
   operation: OperationDefinitionNode,
+  operation_directives?: Directive<any>[],
   variableDefinitions: VariableDefinitions,
   fragments: NamedFragments,
   validateInput?: boolean,
@@ -3834,7 +3912,8 @@ function operationFromAST({
     }),
     variableDefinitions,
     fragmentsIfAny,
-    operation.name?.value
+    operation.name?.value,
+    operation_directives
   );
 }
 
@@ -3889,6 +3968,7 @@ export function operationToDocument(operation: Operation): DocumentNode {
     name: operation.name ? { kind: Kind.NAME, value: operation.name } : undefined,
     selectionSet: operation.selectionSet.toSelectionSetNode(),
     variableDefinitions: operation.variableDefinitions.toVariableDefinitionNodes(),
+    directives: directivesToDirectiveNodes(operation.directives),
   };
   const fragmentASTs: DefinitionNode[] = operation.fragments
     ? operation.fragments?.toFragmentDefinitionNodes()

package/src/specs/connectSpec.ts

@@ -0,0 +1,146 @@
+import { DirectiveLocation, GraphQLError } from 'graphql';
+import { CorePurpose, FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from "./coreSpec";
+import {
+  Schema,
+  NonNullType,
+  InputObjectType,
+  InputFieldDefinition,
+  ListType,
+} from '../definitions';
+import { registerKnownFeature } from '../knownCoreFeatures';
+import { createDirectiveSpecification } from '../directiveAndTypeSpecification';
+
+export const connectIdentity = 'https://specs.apollo.dev/connect';
+
+const CONNECT = "connect";
+const SOURCE = "source";
+const URL_PATH_TEMPLATE = "URLPathTemplate";
+const JSON_SELECTION = "JSONSelection";
+const CONNECT_HTTP = "ConnectHTTP";
+const SOURCE_HTTP = "SourceHTTP";
+const HTTP_HEADER_MAPPING = "HTTPHeaderMapping";
+
+export class ConnectSpecDefinition extends FeatureDefinition {
+  constructor(version: FeatureVersion, readonly minimumFederationVersion: FeatureVersion) {
+    super(new FeatureUrl(connectIdentity, 'connect', version), minimumFederationVersion);
+
+    this.registerDirective(createDirectiveSpecification({
+      name: CONNECT,
+      locations: [DirectiveLocation.FIELD_DEFINITION],
+      repeatable: true,
+      // We "compose" these directives using the  `@join__directive` mechanism,
+      // so they do not need to be composed in the way passing `composes: true`
+      // here implies.
+      composes: false,
+    }));
+
+    this.registerDirective(createDirectiveSpecification({
+      name: SOURCE,
+      locations: [DirectiveLocation.SCHEMA],
+      repeatable: true,
+      composes: false,
+    }));
+
+    this.registerType({ name: URL_PATH_TEMPLATE, checkOrAdd: () => [] });
+    this.registerType({ name: JSON_SELECTION, checkOrAdd: () => [] });
+    this.registerType({ name: CONNECT_HTTP, checkOrAdd: () => [] });
+    this.registerType({ name: SOURCE_HTTP, checkOrAdd: () => [] });
+    this.registerType({ name: HTTP_HEADER_MAPPING, checkOrAdd: () => [] });
+  }
+
+  addElementsToSchema(schema: Schema): GraphQLError[] {
+    /* scalar URLPathTemplate */
+    const URLPathTemplate = this.addScalarType(schema, URL_PATH_TEMPLATE);
+
+    /* scalar JSONSelection */
+    const JSONSelection = this.addScalarType(schema, JSON_SELECTION);
+
+    /*
+      directive @connect(
+        source: String
+        http: ConnectHTTP
+        selection: JSONSelection!
+      ) repeatable on FIELD_DEFINITION
+    */
+    const connect = this.addDirective(schema, CONNECT).addLocations(DirectiveLocation.FIELD_DEFINITION);
+    connect.repeatable = true;
+
+    connect.addArgument(SOURCE, schema.stringType());
+
+    /*
+      input HTTPHeaderMapping {
+        name: String!
+        as: String
+        value: String
+      }
+    */
+    const HTTPHeaderMapping = schema.addType(new InputObjectType(this.typeNameInSchema(schema, HTTP_HEADER_MAPPING)!));
+    HTTPHeaderMapping.addField(new InputFieldDefinition('name')).type =
+      new NonNullType(schema.stringType());
+    HTTPHeaderMapping.addField(new InputFieldDefinition('as')).type =
+      schema.stringType();
+    HTTPHeaderMapping.addField(new InputFieldDefinition('value')).type =
+      schema.stringType();
+
+    /*
+      input ConnectHTTP {
+        GET: URLPathTemplate
+        POST: URLPathTemplate
+        PUT: URLPathTemplate
+        PATCH: URLPathTemplate
+        DELETE: URLPathTemplate
+        body: JSONSelection
+        headers: [HTTPHeaderMapping!]
+      }
+    */
+    const ConnectHTTP = schema.addType(new InputObjectType(this.typeNameInSchema(schema, CONNECT_HTTP)!));
+    ConnectHTTP.addField(new InputFieldDefinition('GET')).type = URLPathTemplate;
+    ConnectHTTP.addField(new InputFieldDefinition('POST')).type = URLPathTemplate;
+    ConnectHTTP.addField(new InputFieldDefinition('PUT')).type = URLPathTemplate;
+    ConnectHTTP.addField(new InputFieldDefinition('PATCH')).type = URLPathTemplate;
+    ConnectHTTP.addField(new InputFieldDefinition('DELETE')).type = URLPathTemplate;
+    ConnectHTTP.addField(new InputFieldDefinition('body')).type = JSONSelection;
+    ConnectHTTP.addField(new InputFieldDefinition('headers')).type =
+      new ListType(new NonNullType(HTTPHeaderMapping));
+    connect.addArgument('http', ConnectHTTP);
+
+    connect.addArgument('selection', JSONSelection);
+
+    /*
+      directive @source(
+        name: String!
+        http: ConnectHTTP
+      ) repeatable on SCHEMA
+    */
+    const source = this.addDirective(schema, SOURCE).addLocations(
+      DirectiveLocation.SCHEMA,
+    );
+    source.repeatable = true;
+    source.addArgument('name', new NonNullType(schema.stringType()));
+
+    /*
+      input SourceHTTP {
+        baseURL: String!
+        headers: [HTTPHeaderMapping!]
+      }
+    */
+    const SourceHTTP = schema.addType(new InputObjectType(this.typeNameInSchema(schema, SOURCE_HTTP)!));
+    SourceHTTP.addField(new InputFieldDefinition('baseURL')).type =
+      new NonNullType(schema.stringType());
+    SourceHTTP.addField(new InputFieldDefinition('headers')).type =
+      new ListType(new NonNullType(HTTPHeaderMapping));
+
+    source.addArgument('http', SourceHTTP);
+
+    return [];
+  }
+
+  get defaultCorePurpose(): CorePurpose {
+    return 'EXECUTION';
+  }
+}
+
+export const CONNECT_VERSIONS = new FeatureDefinitions<ConnectSpecDefinition>(connectIdentity)
+  .add(new ConnectSpecDefinition(new FeatureVersion(0, 1), new FeatureVersion(2, 8)));
+
+registerKnownFeature(CONNECT_VERSIONS);

package/src/specs/coreSpec.ts

@@ -640,6 +640,28 @@ export class FeatureVersion {
     return new this(+match[1], +match[2])
   }
 
+  /**
+   * Find the maximum version in a collection of versions, returning undefined in the case
+   * that the collection is empty.
+   *
+   * # Example
+   * ```
+   * expect(FeatureVersion.max([new FeatureVersion(1, 0), new FeatureVersion(2, 0)])).toBe(new FeatureVersion(2, 0))
+   * expect(FeatureVersion.max([])).toBe(undefined)
+   * ```
+   */
+  public static max(versions: Iterable<FeatureVersion>): FeatureVersion | undefined {
+    let max: FeatureVersion | undefined;
+
+    for (const version of versions) {
+      if (!max || version > max) {
+        max = version;
+      }
+    }
+
+    return max;
+  }
+
   /**
    * Return true if and only if this FeatureVersion satisfies the `required` version
    *

package/src/specs/sourceSpec.ts

@@ -147,15 +147,13 @@ export class SourceSpecDefinition extends FeatureDefinition {
     return this.directive<SourceFieldDirectiveArgs>(schema, 'sourceField')!;
   }
 
-  private getSourceDirectives(schema: Schema, errors: GraphQLError[]) {
+  private getSourceDirectives(schema: Schema) {
     const result: {
       sourceAPI?: DirectiveDefinition<SourceAPIDirectiveArgs>;
       sourceType?: DirectiveDefinition<SourceTypeDirectiveArgs>;
       sourceField?: DirectiveDefinition<SourceFieldDirectiveArgs>;
     } = {};
 
-    let federationVersion: FeatureVersion | undefined;
-
     schema.schemaDefinition.appliedDirectivesOf<LinkDirectiveArgs>('link')
       .forEach(linkDirective => {
         const { url, import: imports } = linkDirective.arguments();
@@ -175,25 +173,8 @@ export class SourceSpecDefinition extends FeatureDefinition {
             }
           });
         }
-        if (featureUrl && featureUrl.name === 'federation') {
-          federationVersion = featureUrl.version;
-        }
       });
 
-    if (result.sourceAPI || result.sourceType || result.sourceField) {
-      // Since this subgraph uses at least one of the @source{API,Type,Field}
-      // directives, it must also use v2.7 or later of federation.
-      if (!federationVersion || federationVersion.lt(this.minimumFederationVersion)) {
-        errors.push(ERRORS.SOURCE_FEDERATION_VERSION_REQUIRED.err(
-          `Schemas that @link to ${
-            sourceIdentity
-          } must also @link to federation version ${
-            this.minimumFederationVersion
-          } or later (found ${federationVersion})`,
-        ));
-      }
-    }
-
     return result;
   }
 
@@ -203,7 +184,7 @@ export class SourceSpecDefinition extends FeatureDefinition {
       sourceAPI,
       sourceType,
       sourceField,
-    } = this.getSourceDirectives(schema, errors);
+    } = this.getSourceDirectives(schema);
 
     if (!(sourceAPI || sourceType || sourceField)) {
       // If none of the @source* directives are present, nothing needs