@apollo/federation-internals 2.4.0-alpha.0 → 2.4.0

package/src/__tests__/operations.test.ts

@@ -4,7 +4,7 @@ import {
   SchemaRootKind,
 } from '../../dist/definitions';
 import { buildSchema } from '../../dist/buildSchema';
-import { Field, FieldSelection, Operation, operationFromDocument, parseOperation, SelectionSet } from '../../dist/operations';
+import { MutableSelectionSet, Operation, operationFromDocument, parseOperation } from '../../dist/operations';
 import './matchers';
 import { DocumentNode, FieldNode, GraphQLError, Kind, OperationDefinitionNode, OperationTypeNode, SelectionNode, SelectionSetNode } from 'graphql';
 
@@ -242,124 +242,6 @@ describe('fragments optimization', () => {
   });
 });
 
-describe('selection set freezing', () => {
-  const schema = parseSchema(`
-    type Query {
-      t: T
-    }
-
-    type T {
-      a: Int
-      b: Int
-    }
-  `);
-
-  const tField = schema.schemaDefinition.rootType('query')!.field('t')!;
-
-  it('throws if one tries to modify a frozen selection set', () => {
-    // Note that we use parseOperation to help us build selection/selection sets because it's more readable/convenient
-    // thant to build the object "programmatically".
-    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet;
-    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet;
-
-    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
-
-    // Control: check we can add to the selection set while not yet frozen
-    expect(s.isFrozen()).toBeFalsy();
-    expect(() => s.mergeIn(s1)).not.toThrow();
-
-    s.freeze();
-    expect(s.isFrozen()).toBeTruthy();
-    expect(() => s.mergeIn(s2)).toThrowError('Cannot add to frozen selection: { t { a } }');
-  });
-
-  it('it does not clone non-frozen selections when adding to another one', () => {
-    // This test is a bit debatable because what it tests is not so much a behaviour
-    // we *need* absolutely to preserve, but rather test how things happens to
-    // behave currently and illustrate the current contrast between frozen and
-    // non-frozen selection set.
-    // That is, this test show what happens if the test
-    //   "it automaticaly clones frozen selections when adding to another one"
-    // is done without freezing.
-
-    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet;
-    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet;
-    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
-
-    s.mergeIn(s1);
-    s.mergeIn(s2);
-
-    expect(s.toString()).toBe('{ t { a b } }');
-
-    // This next assertion is where differs from the case where `s1` is frozen. Namely,
-    // when we do `s.mergeIn(s1)`, then `s` directly references `s1` without cloning
-    // and thus the next modification (`s.mergeIn(s2)`) ends up modifying both `s` and `s1`.
-    // Note that we don't mean by this test that the fact that `s.mergeIn(s1)` does
-    // not clone `s1` is a behaviour one should *rely* on, but it currently done for
-    // efficiencies sake: query planning does a lot of selection set building through
-    // `SelectionSet::mergeIn` and `SelectionSet::add` and we often pass to those method
-    // newly constructed selections as input, so cloning them would wast CPU and early
-    // query planning benchmarking showed that this could add up on the more expansive
-    // plan computations. This is why freezing exists: it allows us to save cloning
-    // in general, but to protect those selection set we know should be immutable
-    // so they do get cloned in such situation.
-    expect(s1.toString()).toBe('{ t { a b } }');
-    expect(s2.toString()).toBe('{ t { b } }');
-  });
-
-  it('it automaticaly clones frozen field selections when merging to another one', () => {
-    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet.freeze();
-    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet.freeze();
-    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
-
-    s.mergeIn(s1);
-    s.mergeIn(s2);
-
-    // We check S is what we expect...
-    expect(s.toString()).toBe('{ t { a b } }');
-
-    // ... but more importantly for this test, that s1/s2 were not modified.
-    expect(s1.toString()).toBe('{ t { a } }');
-    expect(s2.toString()).toBe('{ t { b } }');
-  });
-
-  it('it automaticaly clones frozen fragment selections when merging to another one', () => {
-    // Note: needlessly complex queries, but we're just ensuring the cloning story works when fragments are involved
-    const s1 = parseOperation(schema, `{ ... on Query { t { ... on T { a } } } }`).selectionSet.freeze();
-    const s2 = parseOperation(schema, `{ ... on Query { t { ... on T { b } } } }`).selectionSet.freeze();
-    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
-
-    s.mergeIn(s1);
-    s.mergeIn(s2);
-
-    expect(s.toString()).toBe('{ ... on Query { t { ... on T { a b } } } }');
-
-    expect(s1.toString()).toBe('{ ... on Query { t { ... on T { a } } } }');
-    expect(s2.toString()).toBe('{ ... on Query { t { ... on T { b } } } }');
-  });
-
-  it('it automaticaly clones frozen field selections when adding to another one', () => {
-    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet.freeze();
-    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet.freeze();
-    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
-    const tSelection = new FieldSelection(new Field(tField));
-    s.add(tSelection);
-
-    // Note that this test both checks the auto-cloning for the `add` method, but
-    // also shows that freezing dose apply deeply (since we freeze the whole `s1`/`s2`
-    // but only add some sub-selection of it).
-    tSelection.selectionSet!.add(s1.selections()[0].selectionSet!.selections()[0]);
-    tSelection.selectionSet!.add(s2.selections()[0].selectionSet!.selections()[0]);
-
-    // We check S is what we expect...
-    expect(s.toString()).toBe('{ t { a b } }');
-
-    // ... but more importantly for this test, that s1/s2 were not modified.
-    expect(s1.toString()).toBe('{ t { a } }');
-    expect(s2.toString()).toBe('{ t { b } }');
-  });
-});
-
 describe('validations', () => {
   test.each([
     { directive: '@defer', rootKind: 'mutation' },
@@ -517,3 +399,150 @@ describe('empty branches removal', () => {
     )).toBe('{ u }');
   });
 });
+
+describe('basic operations', () => {
+  const schema = parseSchema(`
+    type Query {
+      t: T
+      i: I
+    }
+
+    type T {
+      v1: Int
+      v2: String
+      v3: I
+    }
+
+    interface I {
+      x: Int
+      y: Int
+    }
+
+    type A implements I {
+      x: Int
+      y: Int
+      a1: String
+      a2: String
+    }
+
+    type B implements I {
+      x: Int
+      y: Int
+      b1: Int
+      b2: T
+    }
+  `);
+
+  const operation = parseOperation(schema, `
+    {
+      t {
+        v1
+        v3 {
+          x
+        }
+      }
+      i {
+        ... on A {
+          a1
+          a2
+        }
+        ... on B {
+          y
+          b2 {
+           v2
+          }
+        }
+      }
+    }
+  `);
+
+  test('forEachElement', () => {
+    // We collect a pair of (parent type, field-or-fragment).
+    const actual: [string, string][] = [];
+    operation.selectionSet.forEachElement((elt) => actual.push([elt.parentType.name, elt.toString()]));
+    expect(actual).toStrictEqual([
+      ['Query', 't'],
+      ['T', 'v1'],
+      ['T', 'v3'],
+      ['I', 'x'],
+      ['Query', 'i'],
+      ['I', '... on A'],
+      ['A', 'a1'],
+      ['A', 'a2'],
+      ['I', '... on B'],
+      ['B', 'y'],
+      ['B', 'b2'],
+      ['T', 'v2'],
+    ]);
+  })
+});
+
+
+describe('MutableSelectionSet', () => {
+  test('memoizer', () => {
+    const schema = parseSchema(`
+      type Query {
+        t: T
+      }
+
+      type T {
+        v1: Int
+        v2: String
+        v3: Int
+        v4: Int
+      }
+    `);
+
+    type Value = {
+      count: number
+    };
+
+    let calls = 0;
+    const sets: string[] = [];
+
+    const queryType = schema.schemaDefinition.rootType('query')!;
+    const ss = MutableSelectionSet.emptyWithMemoized<Value>(
+      queryType,
+      (s) => {
+        sets.push(s.toString());
+        return { count: ++calls };
+      }
+    );
+
+    expect(ss.memoized().count).toBe(1);
+    // Calling a 2nd time with no change to make sure we're not re-generating the value.
+    expect(ss.memoized().count).toBe(1);
+
+    ss.updates().add(parseOperation(schema, `{ t { v1 } }`).selectionSet);
+
+    expect(ss.memoized().count).toBe(2);
+    expect(sets).toStrictEqual(['{}', '{ t { v1 } }']);
+
+    ss.updates().add(parseOperation(schema, `{ t { v3 } }`).selectionSet);
+
+    expect(ss.memoized().count).toBe(3);
+    expect(sets).toStrictEqual(['{}', '{ t { v1 } }', '{ t { v1 v3 } }']);
+
+    // Still making sure we don't re-compute without updates.
+    expect(ss.memoized().count).toBe(3);
+
+    const cloned = ss.clone();
+    expect(cloned.memoized().count).toBe(3);
+
+    cloned.updates().add(parseOperation(schema, `{ t { v2 } }`).selectionSet);
+
+    // The value of `ss` should not have be recomputed, so it should still be 3.
+    expect(ss.memoized().count).toBe(3);
+    // But that of the clone should have changed.
+    expect(cloned.memoized().count).toBe(4);
+    expect(sets).toStrictEqual(['{}', '{ t { v1 } }', '{ t { v1 v3 } }', '{ t { v1 v3 v2 } }']);
+
+    // And here we make sure that if we update the fist selection, we don't have v3 in the set received
+    ss.updates().add(parseOperation(schema, `{ t { v4 } }`).selectionSet);
+    // Here, only `ss` memoized value has been recomputed. But since both increment the same `calls` variable,
+    // the total count should be 5 (even if the previous count for `ss` was only 3).
+    expect(ss.memoized().count).toBe(5);
+    expect(cloned.memoized().count).toBe(4);
+    expect(sets).toStrictEqual(['{}', '{ t { v1 } }', '{ t { v1 v3 } }', '{ t { v1 v3 v2 } }', '{ t { v1 v3 v4 } }']);
+  });
+});

package/src/coreSpec.ts

@@ -1,4 +1,5 @@
 import { ASTNode, DirectiveLocation, GraphQLError, StringValueNode } from "graphql";
+import { URL } from "url";
 import { CoreFeature, Directive, DirectiveDefinition, EnumType, ErrGraphQLAPISchemaValidationFailed, ErrGraphQLValidationFailed, InputType, ListType, NamedType, NonNullType, ScalarType, Schema, SchemaDefinition, SchemaElement, sourceASTs } from "./definitions";
 import { sameType } from "./types";
 import { assert, firstOf } from './utils';

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;
+  });
 }