@apollo/federation-internals 2.4.0-alpha.1 → 2.4.1

package/src/__tests__/schemaUpgrader.test.ts

@@ -212,7 +212,7 @@ test('reject @interfaceObject usage if not all subgraphs are fed2', () => {
 
   const s1 = `
     extend schema
-      @link(url: "https://specs.apollo.dev/federation/v2.4", import: [ "@key", "@interfaceObject"])
+      @link(url: "https://specs.apollo.dev/federation/v2.3", import: [ "@key", "@interfaceObject"])
 
     type Query {
       a: A

package/src/definitions.ts

@@ -32,7 +32,16 @@ import {
   removeAllCoreFeatures,
 } from "./coreSpec";
 import { assert, mapValues, MapWithCachedArrays, removeArrayElement } from "./utils";
-import { withDefaultValues, valueEquals, valueToString, valueToAST, variablesInValue, valueFromAST, valueNodeToConstValueNode, argumentsEquals } from "./values";
+import {
+  withDefaultValues,
+  valueEquals,
+  valueToString,
+  valueToAST,
+  valueFromAST,
+  valueNodeToConstValueNode,
+  argumentsEquals,
+  collectVariablesInValue
+} from "./values";
 import { removeInaccessibleElements } from "./inaccessibleSpec";
 import { printDirectiveDefinition, printSchema } from './print';
 import { sameType } from './types';
@@ -343,54 +352,39 @@ export interface Named {
 export type ExtendableElement = SchemaDefinition | NamedType;
 
 export class DirectiveTargetElement<T extends DirectiveTargetElement<T>> {
-  private _appliedDirectives: Directive<T>[] | undefined;
+  readonly appliedDirectives: Directive<T>[];
 
-  constructor(private readonly _schema: Schema) {}
+  constructor(
+    private readonly _schema: Schema,
+    directives: readonly Directive<any>[] = [],
+  ) {
+    this.appliedDirectives = directives.map((d) => this.attachDirective(d));
+  }
 
   schema(): Schema {
     return this._schema;
   }
 
+  private attachDirective(directive: Directive<any>): Directive<T> {
+    // if the directive is not attached, we can assume we're fine just attaching it to use. Otherwise, we're "copying" it.
+    const toAdd = directive.isAttached()
+      ? new Directive(directive.name, directive.arguments())
+      : directive;
+
+    Element.prototype['setParent'].call(toAdd, this);
+    return toAdd;
+  }
+
   appliedDirectivesOf<TApplicationArgs extends {[key: string]: any} = {[key: string]: any}>(nameOrDefinition: string | DirectiveDefinition<TApplicationArgs>): Directive<T, TApplicationArgs>[] {
     const directiveName = typeof nameOrDefinition === 'string' ? nameOrDefinition : nameOrDefinition.name;
     return this.appliedDirectives.filter(d => d.name == directiveName) as Directive<T, TApplicationArgs>[];
   }
 
-  get appliedDirectives(): readonly Directive<T>[] {
-    return this._appliedDirectives ?? [];
-  }
-
   hasAppliedDirective(nameOrDefinition: string | DirectiveDefinition): boolean {
     const directiveName = typeof nameOrDefinition === 'string' ? nameOrDefinition : nameOrDefinition.name;
     return this.appliedDirectives.some(d => d.name == directiveName);
   }
 
-  applyDirective<TApplicationArgs extends {[key: string]: any} = {[key: string]: any}>(
-    defOrDirective: Directive<T, TApplicationArgs> | DirectiveDefinition<TApplicationArgs>,
-    args?: TApplicationArgs
-  ): Directive<T, TApplicationArgs> {
-    let toAdd: Directive<T, TApplicationArgs>;
-    if (defOrDirective instanceof Directive) {
-      if (defOrDirective.schema() != this.schema()) {
-        throw new Error(`Cannot add directive ${defOrDirective} to ${this} as it is attached to another schema`);
-      }
-      toAdd = defOrDirective;
-      if (args) {
-        toAdd.setArguments(args);
-      }
-    } else {
-      toAdd = new Directive<T, TApplicationArgs>(defOrDirective.name, args ?? Object.create(null));
-    }
-    Element.prototype['setParent'].call(toAdd, this);
-    // TODO: we should typecheck arguments or our TApplicationArgs business is just a lie.
-    if (this._appliedDirectives) {
-      this._appliedDirectives.push(toAdd);
-    } else {
-      this._appliedDirectives = [ toAdd ];
-    }
-    return toAdd;
-  }
-
   appliedDirectivesToDirectiveNodes() : ConstDirectiveNode[] | undefined {
     if (this.appliedDirectives.length == 0) {
       return undefined;
@@ -414,8 +408,10 @@ export class DirectiveTargetElement<T extends DirectiveTargetElement<T>> {
       : ' ' + this.appliedDirectives.join(' ');
   }
 
-  variablesInAppliedDirectives(): Variables {
-    return this.appliedDirectives.reduce((acc: Variables, d) => mergeVariables(acc, variablesInArguments(d.arguments())), []);
+  collectVariablesInAppliedDirectives(collector: VariableCollector) {
+    for (const applied of this.appliedDirectives) {
+      collector.collectInArguments(applied.arguments());
+    }
   }
 }
 
@@ -3069,7 +3065,7 @@ export class Directive<
   // applied to a field that is part of an extension, the field will have its extension set, but not the underlying directive.
   private _extension?: Extension<any>;
 
-  constructor(readonly name: string, private _args: TArgs) {
+  constructor(readonly name: string, private _args: TArgs = Object.create(null)) {
     super();
   }
 
@@ -3314,38 +3310,38 @@ export class Variable {
 
 export type Variables = readonly Variable[];
 
-export function mergeVariables(v1s: Variables, v2s: Variables): Variables {
-  if (v1s.length == 0) {
-    return v2s;
+export class VariableCollector {
+  private readonly _variables = new Map<string, Variable>();
+
+  add(variable: Variable) {
+    this._variables.set(variable.name, variable);
   }
-  if (v2s.length == 0) {
-    return v1s;
+
+  addAll(variables: Variables) {
+    for (const variable of variables) {
+      this.add(variable);
+    }
   }
-  const res: Variable[] = v1s.concat();
-  for (const v of v2s) {
-    if (!containsVariable(v1s, v)) {
-      res.push(v);
+
+  collectInArguments(args: {[key: string]: any}) {
+    for (const value of Object.values(args)) {
+      collectVariablesInValue(value, this);
     }
   }
-  return res;
-}
 
-export function containsVariable(variables: Variables, toCheck: Variable): boolean {
-  return variables.some(v => v.name == toCheck.name);
+  variables() {
+    return mapValues(this._variables);
+  }
+
+  toString(): string {
+    return this.variables().toString();
+  }
 }
 
 export function isVariable(v: any): v is Variable {
   return v instanceof Variable;
 }
 
-export function variablesInArguments(args: {[key: string]: any}): Variables {
-  let variables: Variables = [];
-  for (const value of Object.values(args)) {
-    variables = mergeVariables(variables, variablesInValue(value));
-  }
-  return variables;
-}
-
 export class VariableDefinition extends DirectiveTargetElement<VariableDefinition> {
   constructor(
     schema: Schema,

package/src/federation.ts

@@ -48,7 +48,7 @@ import {
 } from "graphql";
 import { KnownTypeNamesInFederationRule } from "./validation/KnownTypeNamesInFederationRule";
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
-import { parseSelectionSet, selectionOfElement, SelectionSet } from './operations';
+import { parseSelectionSet, SelectionSet } from './operations';
 import { TAG_VERSIONS } from "./tagSpec";
 import {
   errorCodeDef,
@@ -129,7 +129,7 @@ function validateFieldSetSelections({
   allowFieldsWithArguments: boolean,
 }): void {
   for (const selection of selectionSet.selections()) {
-    const appliedDirectives = selection.element().appliedDirectives;
+    const appliedDirectives = selection.element.appliedDirectives;
     if (appliedDirectives.length > 0) {
       onError(ERROR_CATEGORIES.DIRECTIVE_IN_FIELDS_ARG.get(directiveName).err(
         `cannot have directive applications in the @${directiveName}(fields:) argument but found ${appliedDirectives.join(', ')}.`,
@@ -137,7 +137,7 @@ function validateFieldSetSelections({
     }
 
     if (selection.kind === 'FieldSelection') {
-      const field = selection.element().definition;
+      const field = selection.element.definition;
       const isExternal = metadata.isFieldExternal(field);
       if (!allowFieldsWithArguments && field.hasArguments()) {
         onError(ERROR_CATEGORIES.FIELDS_HAS_ARGS.get(directiveName).err(
@@ -1817,12 +1817,17 @@ class ExternalTester {
   private collectProvidedFields() {
     for (const provides of this.metadata().providesDirective().applications()) {
       const parent = provides.parent as FieldDefinition<CompositeType>;
-      collectTargetFields({
-        parentType: baseType(parent.type!) as CompositeType,
-        directive: provides as Directive<any, {fields: any}>,
-        includeInterfaceFieldsImplementations: true,
-        validate: false,
-      }).forEach((f) => this.providedFields.add(f.coordinate));
+      const parentType = baseType(parent.type!);
+      // If `parentType` is not a composite, that means an invalid @provides, but we ignore such errors
+      // for now (also why we pass 'validate: false'). Proper errors will be thrown later during validation.
+      if (isCompositeType(parentType)) {
+        collectTargetFields({
+          parentType,
+          directive: provides as Directive<any, {fields: any}>,
+          includeInterfaceFieldsImplementations: true,
+          validate: false,
+        }).forEach((f) => this.providedFields.add(f.coordinate));
+      }
     }
   }
 
@@ -1854,7 +1859,7 @@ class ExternalTester {
 
   selectsAnyExternalField(selectionSet: SelectionSet): boolean {
     for (const selection of selectionSet.selections()) {
-      if (selection.kind === 'FieldSelection' && this.isExternal(selection.element().definition)) {
+      if (selection.kind === 'FieldSelection' && this.isExternal(selection.element.definition)) {
         return true;
       }
       if (selection.selectionSet) {
@@ -1966,7 +1971,7 @@ function selectsNonExternalLeafField(selection: SelectionSet): boolean {
   return selection.selections().some(s => {
     if (s.kind === 'FieldSelection') {
       // If it's external, we're good and don't need to recurse.
-      if (isExternalOrHasExternalImplementations(s.field.definition)) {
+      if (isExternalOrHasExternalImplementations(s.element.definition)) {
         return false;
       }
       // Otherwise, we select a non-external if it's a leaf, or the sub-selection does.
@@ -1978,25 +1983,24 @@ function selectsNonExternalLeafField(selection: SelectionSet): boolean {
 }
 
 function withoutNonExternalLeafFields(selectionSet: SelectionSet): SelectionSet {
-  const newSelectionSet = new SelectionSet(selectionSet.parentType);
-  for (const selection of selectionSet.selections()) {
+  return selectionSet.lazyMap((selection) => {
     if (selection.kind === 'FieldSelection') {
-      if (isExternalOrHasExternalImplementations(selection.field.definition)) {
+      if (isExternalOrHasExternalImplementations(selection.element.definition)) {
         // That field is external, so we can add the selection back entirely.
-        newSelectionSet.add(selection);
-        continue;
+        return selection;
       }
     }
-    // Note that for fragments will always be true (and we just recurse), while
-    // for fields, we'll only get here if the field is not external, and so
-    // we want to add the selection only if it's not a leaf and even then, only
-    // the part where we've recursed.
     if (selection.selectionSet) {
+      // Note that for fragments this will always be true (and we just recurse), while
+      // for fields, we'll only get here if the field is not external, and so
+      // we want to add the selection only if it's not a leaf and even then, only
+      // the part where we've recursed.
       const updated = withoutNonExternalLeafFields(selection.selectionSet);
       if (!updated.isEmpty()) {
-        newSelectionSet.add(selectionOfElement(selection.element(), updated));
+        return selection.withUpdatedSelectionSet(updated);
       }
     }
-  }
-  return newSelectionSet;
+    // We skip that selection.
+    return undefined;
+  });
 }