@apollo/federation-internals 2.9.1 → 2.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/federation-internals",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "Apollo Federation internal utilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/error.ts

@@ -710,6 +710,36 @@ const CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS = makeCodeDefinition(
   { addedIn: '2.7.0' },
 );
 
+const COST_APPLIED_TO_INTERFACE_FIELD = makeCodeDefinition(
+  'COST_APPLIED_TO_INTERFACE_FIELD',
+  'The `@cost` directive must be applied to concrete types',
+  { addedIn: '2.9.2' },
+);
+
+const LIST_SIZE_APPLIED_TO_NON_LIST = makeCodeDefinition(
+  'LIST_SIZE_APPLIED_TO_NON_LIST',
+  'The `@listSize` directive must be applied to list types',
+  { addedIn: '2.9.2' },
+);
+
+const LIST_SIZE_INVALID_ASSUMED_SIZE = makeCodeDefinition(
+  'LIST_SIZE_INVALID_ASSUMED_SIZE',
+  'The `@listSize` directive assumed size cannot be negative',
+  { addedIn: '2.9.2' },
+);
+
+const LIST_SIZE_INVALID_SLICING_ARGUMENT = makeCodeDefinition(
+  'LIST_SIZE_INVALID_SLICING_ARGUMENT',
+  'The `@listSize` directive must have existing integer slicing arguments',
+  { addedIn: '2.9.2' },
+);
+
+const LIST_SIZE_INVALID_SIZED_FIELD = makeCodeDefinition(
+  'LIST_SIZE_INVALID_SIZED_FIELD',
+  'The `@listSize` directive must reference existing list fields as sized fields',
+  { addedIn: '2.9.2' },
+);
+
 export const ERROR_CATEGORIES = {
   DIRECTIVE_FIELDS_MISSING_EXTERNAL,
   DIRECTIVE_UNSUPPORTED_ON_INTERFACE,
@@ -824,6 +854,12 @@ export const ERRORS = {
   SOURCE_FIELD_SELECTION_INVALID,
   SOURCE_FIELD_NOT_ON_ROOT_OR_ENTITY_FIELD,
   CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS,
+  // Errors related to demand control
+  COST_APPLIED_TO_INTERFACE_FIELD,
+  LIST_SIZE_APPLIED_TO_NON_LIST,
+  LIST_SIZE_INVALID_ASSUMED_SIZE,
+  LIST_SIZE_INVALID_SIZED_FIELD,
+  LIST_SIZE_INVALID_SLICING_ARGUMENT,
 };
 
 const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorCodeDefinition}, codeDef: ErrorCodeDefinition) => { obj[codeDef.code] = codeDef; return obj; }, {});

package/src/federation.ts

@@ -36,6 +36,8 @@ import {
   isListType,
   isWrapperType,
   possibleRuntimeTypes,
+  isIntType,
+  Type,
 } from "./definitions";
 import { assert, MultiMap, printHumanReadableList, OrderedMap, mapValues, assertUnreachable } from "./utils";
 import { SDLValidationRule } from "graphql/validation/ValidationContext";
@@ -100,7 +102,7 @@ import {
   SourceFieldDirectiveArgs,
   SourceTypeDirectiveArgs,
 } from "./specs/sourceSpec";
-import { CostDirectiveArguments, ListSizeDirectiveArguments } from "./specs/costSpec";
+import { COST_VERSIONS, CostDirectiveArguments, ListSizeDirectiveArguments, costIdentity } from "./specs/costSpec";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
@@ -1055,6 +1057,123 @@ function validateShareableNotRepeatedOnSameDeclaration(
     }
   }
 }
+
+function validateCostNotAppliedToInterface(application: Directive<SchemaElement<any, any>, CostDirectiveArguments>, errorCollector: GraphQLError[]) {
+  const parent = application.parent;
+  // @cost cannot be used on interfaces https://ibm.github.io/graphql-specs/cost-spec.html#sec-No-Cost-on-Interface-Fields
+  if (parent instanceof FieldDefinition && parent.parent instanceof InterfaceType) {
+    errorCollector.push(ERRORS.COST_APPLIED_TO_INTERFACE_FIELD.err(
+      `@cost cannot be applied to interface "${parent.coordinate}"`,
+      { nodes: sourceASTs(application, parent) }
+    ));
+  }
+}
+
+function validateListSizeAppliedToList(
+  application: Directive<SchemaElement<any, any>, ListSizeDirectiveArguments>,
+  parent: FieldDefinition<CompositeType>,
+  errorCollector: GraphQLError[],
+) {
+  const { sizedFields = [] } = application.arguments();
+  // @listSize must be applied to a list https://ibm.github.io/graphql-specs/cost-spec.html#sec-Valid-List-Size-Target
+  if (!sizedFields.length && parent.type && !isListType(parent.type)) {
+    errorCollector.push(ERRORS.LIST_SIZE_APPLIED_TO_NON_LIST.err(
+      `"${parent.coordinate}" is not a list`,
+      { nodes: sourceASTs(application, parent) },
+    ));
+  }
+}
+
+function validateAssumedSizeNotNegative(
+  application: Directive<SchemaElement<any, any>, ListSizeDirectiveArguments>,
+  parent: FieldDefinition<CompositeType>,
+  errorCollector: GraphQLError[]
+) {
+  const { assumedSize } = application.arguments();
+  // Validate assumed size, but we differ from https://ibm.github.io/graphql-specs/cost-spec.html#sec-Valid-Assumed-Size.
+  // Assumed size is used as a backup for slicing arguments in the event they are both specified. 
+  // The spec aims to rule out cases when the assumed size will never be used because there is always
+  // a slicing argument. Two applications which are compliant with that validation rule can be merged
+  // into an application which is not compliant, thus we need to handle this case gracefully at runtime regardless.
+  // We omit this check to keep the validations to those that will otherwise cause runtime failures.
+  //
+  // With all that said, assumed size should not be negative.
+  if (assumedSize !== undefined && assumedSize !== null && assumedSize < 0) {
+    errorCollector.push(ERRORS.LIST_SIZE_INVALID_ASSUMED_SIZE.err(
+      `Assumed size of "${parent.coordinate}" cannot be negative`,
+      { nodes: sourceASTs(application, parent) },
+    ));
+  }
+}
+
+function isNonNullIntType(ty: Type): boolean {
+  return isNonNullType(ty) && isIntType(ty.ofType)
+}
+
+function validateSlicingArgumentsAreValidIntegers(
+  application: Directive<SchemaElement<any, any>, ListSizeDirectiveArguments>,
+  parent: FieldDefinition<CompositeType>,
+  errorCollector: GraphQLError[]
+) {
+  const { slicingArguments = [] } = application.arguments();
+  // Validate slicingArguments https://ibm.github.io/graphql-specs/cost-spec.html#sec-Valid-Slicing-Arguments-Target
+  for (const slicingArgumentName of slicingArguments) {
+    const slicingArgument = parent.argument(slicingArgumentName);
+    if (!slicingArgument?.type) {
+      // Slicing arguments must be one of the field's arguments
+      errorCollector.push(ERRORS.LIST_SIZE_INVALID_SLICING_ARGUMENT.err(
+        `Slicing argument "${slicingArgumentName}" is not an argument of "${parent.coordinate}"`,
+        { nodes: sourceASTs(application, parent) }
+      ));
+    } else if (!isIntType(slicingArgument.type) && !isNonNullIntType(slicingArgument.type)) {
+      // Slicing arguments must be Int or Int!
+      errorCollector.push(ERRORS.LIST_SIZE_INVALID_SLICING_ARGUMENT.err(
+        `Slicing argument "${slicingArgument.coordinate}" must be Int or Int!`,
+        { nodes: sourceASTs(application, parent) }
+      ));
+    }
+  }
+}
+
+function isNonNullListType(ty: Type): boolean {
+  return isNonNullType(ty) && isListType(ty.ofType)
+}
+
+function validateSizedFieldsAreValidLists(
+  application: Directive<SchemaElement<any, any>, ListSizeDirectiveArguments>,
+  parent: FieldDefinition<CompositeType>,
+  errorCollector: GraphQLError[]
+) {
+  const { sizedFields = [] } = application.arguments();
+  // Validate sizedFields https://ibm.github.io/graphql-specs/cost-spec.html#sec-Valid-Sized-Fields-Target
+  if (sizedFields.length) {
+    if (!parent.type || !isCompositeType(parent.type)) {
+      // The output type must have fields
+      errorCollector.push(ERRORS.LIST_SIZE_INVALID_SIZED_FIELD.err(
+        `Sized fields cannot be used because "${parent.type}" is not a composite type`,
+        { nodes: sourceASTs(application, parent)}
+      ));
+    } else {
+      for (const sizedFieldName of sizedFields) {
+        const sizedField = parent.type.field(sizedFieldName);
+        if (!sizedField) {
+          // Sized fields must be present on the output type
+          errorCollector.push(ERRORS.LIST_SIZE_INVALID_SIZED_FIELD.err(
+            `Sized field "${sizedFieldName}" is not a field on type "${parent.type.coordinate}"`,
+            { nodes: sourceASTs(application, parent) }
+          ));
+        } else if (!sizedField.type || !(isListType(sizedField.type) || isNonNullListType(sizedField.type))) {
+          // Sized fields must be lists
+          errorCollector.push(ERRORS.LIST_SIZE_APPLIED_TO_NON_LIST.err(
+            `Sized field "${sizedField.coordinate}" is not a list`,
+            { nodes: sourceASTs(application, parent) },
+          ));
+        }
+      }
+    }
+  }
+}
+
 export class FederationMetadata {
   private _externalTester?: ExternalTester;
   private _sharingPredicate?: (field: FieldDefinition<CompositeType>) => boolean;
@@ -1689,7 +1808,7 @@ export class FederationBlueprint extends SchemaBlueprint {
         const keyApplications = objectType.appliedDirectivesOf(keyDirective);
         if (!keyApplications.some(app => app.arguments().resolvable || app.arguments().resolvable === undefined)) {
           errorCollector.push(ERRORS.CONTEXT_NO_RESOLVABLE_KEY.err(
-            `Object "${objectType.coordinate}" has no resolvable key but has an a field with a contextual argument.`,
+            `Object "${objectType.coordinate}" has no resolvable key but has a field with a contextual argument.`,
             { nodes: sourceASTs(objectType) }
           ));
         }
@@ -1736,6 +1855,26 @@ export class FederationBlueprint extends SchemaBlueprint {
       }
     }
 
+    const costFeature = schema.coreFeatures?.getByIdentity(costIdentity);
+    const costSpec = costFeature && COST_VERSIONS.find(costFeature.url.version);
+    const costDirective = costSpec?.costDirective(schema);
+    const listSizeDirective = costSpec?.listSizeDirective(schema);
+
+    // Validate @cost
+    for (const application of costDirective?.applications() ?? []) {
+      validateCostNotAppliedToInterface(application, errorCollector);
+    }
+
+    // Validate @listSize
+    for (const application of listSizeDirective?.applications() ?? []) {
+      const parent = application.parent;
+      assert(parent instanceof FieldDefinition, "@listSize can only be applied to FIELD_DEFINITION");
+      validateListSizeAppliedToList(application, parent, errorCollector);
+      validateAssumedSizeNotNegative(application, parent, errorCollector);
+      validateSlicingArgumentsAreValidIntegers(application, parent, errorCollector);
+      validateSizedFieldsAreValidLists(application, parent, errorCollector);
+    }
+
     return errorCollector;
   }
 
@@ -2141,12 +2280,14 @@ export function parseFieldSetArgument({
   fieldAccessor,
   validate,
   decorateValidationErrors = true,
+  normalize = false,
 }: {
   parentType: CompositeType,
   directive: Directive<SchemaElement<any, any>, {fields: any}>,
   fieldAccessor?: (type: CompositeType, fieldName: string) => FieldDefinition<any> | undefined,
   validate?: boolean,
   decorateValidationErrors?: boolean,
+  normalize?: boolean,
 }): SelectionSet {
   try {
     const selectionSet = parseSelectionSet({
@@ -2163,7 +2304,9 @@ export function parseFieldSetArgument({
         }
       });
     }
-    return selectionSet;
+    return normalize
+      ? selectionSet.normalize({ parentType, recursive: true })
+      : selectionSet;
   } catch (e) {
     if (!(e instanceof GraphQLError) || !decorateValidationErrors) {
       throw e;

package/src/operations.ts

@@ -69,7 +69,7 @@ function haveSameDirectives<TElement extends OperationElement>(op1: TElement, op
 }
 
 abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> extends DirectiveTargetElement<T> {
-  private attachements?: Map<string, string>;
+  private attachments?: Map<string, string>;
 
   constructor(
     schema: Schema,
@@ -97,21 +97,21 @@ abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> e
 
   protected abstract collectVariablesInElement(collector: VariableCollector): void;
 
-  addAttachement(key: string, value: string) {
-    if (!this.attachements) {
-      this.attachements = new Map();
+  addAttachment(key: string, value: string) {
+    if (!this.attachments) {
+      this.attachments = new Map();
     }
-    this.attachements.set(key, value);
+    this.attachments.set(key, value);
   }
 
-  getAttachement(key: string): string | undefined {
-    return this.attachements?.get(key);
+  getAttachment(key: string): string | undefined {
+    return this.attachments?.get(key);
   }
 
-  protected copyAttachementsTo(elt: AbstractOperationElement<any>) {
-    if (this.attachements) {
-      for (const [k, v] of this.attachements.entries()) {
-        elt.addAttachement(k, v);
+  protected copyAttachmentsTo(elt: AbstractOperationElement<any>) {
+    if (this.attachments) {
+      for (const [k, v] of this.attachments.entries()) {
+        elt.addAttachment(k, v);
       }
     }
   }
@@ -170,6 +170,17 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
   baseType(): NamedType {
     return baseType(this.definition.type!);
   }
+
+  copy(): Field<TArgs> {
+    const newField = new Field<TArgs>(
+      this.definition,
+      this.args,
+      this.appliedDirectives,
+      this.alias,
+    );
+    this.copyAttachmentsTo(newField);
+    return newField;
+  }
   
   withUpdatedArguments(newArgs: TArgs): Field<TArgs> {
     const newField = new Field<TArgs>(
@@ -178,7 +189,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -189,7 +200,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -200,7 +211,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       newAlias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -211,7 +222,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       newDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -505,13 +516,13 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     // schema (typically, the supergraph) than `this.sourceType` (typically, a subgraph), then the new condition uses the
     // definition of the proper schema (the supergraph in such cases, instead of the subgraph).
     const newFragment = new FragmentElement(newSourceType, newCondition?.name, this.appliedDirectives);
-    this.copyAttachementsTo(newFragment);
+    this.copyAttachmentsTo(newFragment);
     return newFragment;
   }
 
   withUpdatedDirectives(newDirectives: Directive<OperationElement>[]): FragmentElement {
     const newFragment = new FragmentElement(this.sourceType, this.typeCondition, newDirectives);
-    this.copyAttachementsTo(newFragment);
+    this.copyAttachmentsTo(newFragment);
     return newFragment;
   }
 
@@ -590,7 +601,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     }
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
-    this.copyAttachementsTo(updated);
+    this.copyAttachmentsTo(updated);
     return updated;
   }
 
@@ -655,7 +666,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
       .concat(new Directive<FragmentElement>(deferDirective.name, newDeferArgs));
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
-    this.copyAttachementsTo(updated);
+    this.copyAttachmentsTo(updated);
     return updated;
   }
 
@@ -1182,6 +1193,11 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
     }
   }
 
+  collectVariables(collector: VariableCollector) {
+    this.selectionSet.collectVariables(collector);
+    this.collectVariablesInAppliedDirectives(collector);
+  }
+
   toFragmentDefinitionNode() : FragmentDefinitionNode {
     return {
       kind: Kind.FRAGMENT_DEFINITION,
@@ -1647,10 +1663,10 @@ export class SelectionSet {
         }
 
         return new FragmentSpreadSelection(this.parentType, namedFragments, fragmentDefinition, []);
-      } else if (selection.kind === 'FieldSelection') {
-        if (selection.selectionSet) {
-          selection = selection.withUpdatedSelectionSet(selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections)[0]);
-        }
+      }
+
+      if (selection.selectionSet) {
+        selection = selection.withUpdatedSelectionSet(selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections)[0]);
       }
       return selection;
     });
@@ -2103,10 +2119,10 @@ export class SelectionSet {
     // By default, we will print the selection the order in which things were added to it.
     // If __typename is selected however, we put it first. It's a detail but as __typename is a bit special it looks better,
     // and it happens to mimic prior behavior on the query plan side so it saves us from changing tests for no good reasons.
-    const isNonAliasedTypenameSelection = (s: Selection) => s.kind === 'FieldSelection' && !s.element.alias && s.element.name === typenameFieldName;
-    const typenameSelection = this._selections.find((s) => isNonAliasedTypenameSelection(s));
+    const isPlainTypenameSelection = (s: Selection) => s.kind === 'FieldSelection' && s.isPlainTypenameField();
+    const typenameSelection = this._selections.find((s) => isPlainTypenameSelection(s));
     if (typenameSelection) {
-      return [typenameSelection].concat(this.selections().filter(s => !isNonAliasedTypenameSelection(s)));
+      return [typenameSelection].concat(this.selections().filter(s => !isPlainTypenameSelection(s)));
     } else {
       return this._selections;
     }
@@ -3042,6 +3058,19 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this.element.definition.name === typenameFieldName;
   }
 
+  // Is this a plain simple __typename without any directive or alias?
+  isPlainTypenameField(): boolean {
+    return this.element.definition.name === typenameFieldName
+        && this.element.appliedDirectives.length == 0
+        && !this.element.alias;
+  }
+
+  withAttachment(key: string, value: string): FieldSelection {
+    const updatedField = this.element.copy();
+    updatedField.addAttachment(key, value);
+    return this.withUpdatedElement(updatedField);
+  }
+
   withUpdatedComponents(field: Field<any>, selectionSet: SelectionSet | undefined): FieldSelection {
     if (this.element === field && this.selectionSet === selectionSet) {
       return this;