@apollo/federation-internals 2.7.2 → 2.7.3

package/package.json

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

package/src/definitions.ts

@@ -392,26 +392,11 @@ export class DirectiveTargetElement<T extends DirectiveTargetElement<T>> {
   }
 
   appliedDirectivesToDirectiveNodes() : ConstDirectiveNode[] | undefined {
-    if (this.appliedDirectives.length == 0) {
-      return undefined;
-    }
-
-    return this.appliedDirectives.map(directive => {
-      return {
-        kind: Kind.DIRECTIVE,
-        name: {
-          kind: Kind.NAME,
-          value: directive.name,
-        },
-        arguments: directive.argumentsToAST()
-      };
-    });
+    return directivesToDirectiveNodes(this.appliedDirectives);
   }
 
   appliedDirectivesToString(): string {
-    return this.appliedDirectives.length == 0
-      ? ''
-      : ' ' + this.appliedDirectives.join(' ');
+    return directivesToString(this.appliedDirectives);
   }
 
   collectVariablesInAppliedDirectives(collector: VariableCollector) {
@@ -3257,6 +3242,37 @@ export class Directive<
   }
 }
 
+/**
+ * Formats a Directive array as a string (with a leading space, if present).
+ */
+export function directivesToString(directives?: readonly Directive<any>[])
+  : string
+{
+  return (!directives || directives.length == 0)
+        ? ''
+        : ' ' + directives.join(' ');
+}
+
+/**
+ * Converts a Directive array into DirectiveNode array.
+ */
+export function directivesToDirectiveNodes(directives?: readonly Directive<any>[])
+  : ConstDirectiveNode[] | undefined
+{
+  return (!directives || directives.length === 0)
+    ? undefined
+    : directives.map(directive => {
+      return {
+        kind: Kind.DIRECTIVE,
+        name: {
+          kind: Kind.NAME,
+          value: directive.name,
+        },
+        arguments: directive.argumentsToAST()
+      };
+    });
+}
+
 /**
  * Checks if 2 directive applications should be considered equal.
  *

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
     );
   }
 
@@ -982,6 +986,7 @@ export class Operation {
       this.variableDefinitions,
       fragments,
       this.name,
+      this.directives
     );
   }
 
@@ -1053,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);
   }
 }
 
@@ -1219,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,
@@ -2077,6 +2090,7 @@ export class SelectionSet {
     variableDefinitions: VariableDefinitions,
     fragments: NamedFragments | undefined,
     operationName?: string,
+    directives?: readonly Directive<any>[],
     expandFragments: boolean = false,
     prettyPrint: boolean = true
   ): string {
@@ -2090,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);
   }
 
   /**
@@ -2873,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()) {
@@ -3562,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;
   }
@@ -3588,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 },
@@ -3744,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);
     }
   }
 }
@@ -3832,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.
@@ -3842,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:
@@ -3875,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,
@@ -3906,7 +3912,8 @@ function operationFromAST({
     }),
     variableDefinitions,
     fragmentsIfAny,
-    operation.name?.value
+    operation.name?.value,
+    operation_directives
   );
 }
 
@@ -3961,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()