@apollo/federation-internals 2.0.0-alpha.2 → 2.0.0-alpha.3

package/src/__tests__/subgraphValidation.test.ts

@@ -0,0 +1,452 @@
+import { DocumentNode } from 'graphql';
+import gql from 'graphql-tag';
+import { errorCauses } from '..';
+import { buildSubgraph } from "../federation"
+
+// Builds the provided subgraph (using name 'S' for the subgraph) and, if the
+// subgraph is invalid/has errors, return those errors as a list of [code, message].
+// If the subgraph is valid, return undefined.
+function buildForErrors(subgraphDefs: DocumentNode, subgraphName: string = 'S'): [string, string][] | undefined {
+  try {
+    buildSubgraph(subgraphName, subgraphDefs);
+    return undefined;
+  } catch (e) {
+    const causes = errorCauses(e);
+    if (!causes) {
+      throw e;
+    }
+    return causes.map((err) => [err.extensions.code, err.message]);
+  }
+}
+
+describe('fieldset-based directives', () => {
+  it('rejects field defined with arguments in @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "f") {
+        f(x: Int): Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_FIELDS_HAS_ARGS', '[S] On type "T", for @key(fields: "f"): field T.f cannot be included because it has arguments (fields with argument are not allowed in @key)']
+    ]);
+  });
+
+  it('rejects field defined with arguments in @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "f")
+      }
+
+      type T {
+        f(x: Int): Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_FIELDS_HAS_ARGS', '[S] On field "Query.t", for @provides(fields: "f"): field T.f cannot be included because it has arguments (fields with argument are not allowed in @provides)']
+    ]);
+  });
+
+  it('rejects field defined with arguments in @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f(x: Int): Int @external
+        g: Int @requires(fields: "f")
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_FIELDS_HAS_ARGS', '[S] On field "T.g", for @requires(fields: "f"): field T.f cannot be included because it has arguments (fields with argument are not allowed in @requires)']
+    ]);
+  });
+
+  it('rejects @provides on non-external fields', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "f")
+      }
+
+      type T {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_FIELDS_MISSING_EXTERNAL', '[S] On field "Query.t", for @provides(fields: "f"): field "T.f" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)']
+    ]);
+  });
+
+  it('rejects @requires on non-external fields', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f: Int
+        g: Int @requires(fields: "f")
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_FIELDS_MISSING_EXTERNAL', '[S] On field "T.g", for @requires(fields: "f"): field "T.f" should not be part of a @requires since it is already provided by this subgraph (it is not marked @external)']
+    ]);
+  });
+
+  it('rejects @key on interfaces', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      interface T @key(fields: "f") {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_UNSUPPORTED_ON_INTERFACE', '[S] Cannot use @key on interface "T": @key is not yet supported on interfaces'],
+    ]);
+  });
+
+  it('rejects @provides on interfaces', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      interface T {
+        f: U @provides(fields: "g")
+      }
+
+      type U {
+        g: Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_UNSUPPORTED_ON_INTERFACE', '[S] Cannot use @provides on field "T.f" of parent type "T": @provides is not yet supported within interfaces'],
+    ]);
+  });
+
+  it('rejects @requires on interfaces', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      interface T {
+        f: Int @external
+        g: Int @requires(fields: "f")
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_UNSUPPORTED_ON_INTERFACE', '[S] Cannot use @requires on field "T.g" of parent type "T": @requires is not yet supported within interfaces' ],
+    ]);
+  });
+
+  it('rejects unused @external', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f: Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).'],
+    ]);
+  });
+
+  it('rejects @provides on non-object fields', () => {
+    const subgraph =  gql`
+      type Query {
+        t: Int @provides(fields: "f")
+      }
+
+      type T {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_ON_NON_OBJECT_FIELD', '[S] Invalid @provides directive on field "Query.t": field has type "Int" which is not a Composite Type'],
+    ]);
+  });
+
+  it('rejects a non-string argument to @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: ["f"]) {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_INVALID_FIELDS_TYPE', '[S] On type "T", for @key(fields: ["f"]): Invalid value for argument "fields": must be a string.'],
+    ]);
+  });
+
+  it('rejects a non-string argument to @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: ["f"])
+      }
+
+      type T {
+        f: Int @external
+      }
+    `
+    // Note: since the error here is that we cannot parse the key `fields`, this also mean that @external on
+    // `f` will appear unused and we get an error for it. It's kind of hard to avoid cleanly and hopefully
+    // not a big deal (having errors dependencies is not exactly unheard of).
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_INVALID_FIELDS_TYPE', '[S] On field "Query.t", for @provides(fields: ["f"]): Invalid value for argument "fields": must be a string.'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  it('rejects a non-string argument to @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f: Int @external
+        g: Int @requires(fields: ["f"])
+      }
+    `
+    // Note: since the error here is that we cannot parse the key `fields`, this also mean that @external on
+    // `f` will appear unused and we get an error for it. It's kind of hard to avoid cleanly and hopefully
+    // not a big deal (having errors dependencies is not exactly unheard of).
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_INVALID_FIELDS_TYPE', '[S] On field "T.g", for @requires(fields: ["f"]): Invalid value for argument "fields": must be a string.'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  // Special case of non-string argument, specialized because it hits a different
+  // code-path due to enum values being parsed as string and requiring special care.
+  it('rejects an enum-like argument to @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: f) {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_INVALID_FIELDS_TYPE', '[S] On type "T", for @key(fields: f): Invalid value for argument "fields": must be a string.'],
+    ]);
+  });
+
+  // Special case of non-string argument, specialized because it hits a different
+  // code-path due to enum values being parsed as string and requiring special care.
+  it('rejects an enum-lik argument to @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: f)
+      }
+
+      type T {
+        f: Int @external
+      }
+    `
+    // Note: since the error here is that we cannot parse the key `fields`, this also mean that @external on
+    // `f` will appear unused and we get an error for it. It's kind of hard to avoid cleanly and hopefully
+    // not a big deal (having errors dependencies is not exactly unheard of).
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_INVALID_FIELDS_TYPE', '[S] On field "Query.t", for @provides(fields: f): Invalid value for argument "fields": must be a string.'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  // Special case of non-string argument, specialized because it hits a different
+  // code-path due to enum values being parsed as string and requiring special care.
+  it('rejects an enum-like argument to @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f: Int @external
+        g: Int @requires(fields: f)
+      }
+    `
+    // Note: since the error here is that we cannot parse the key `fields`, this also mean that @external on
+    // `f` will appear unused and we get an error for it. It's kind of hard to avoid cleanly and hopefully
+    // not a big deal (having errors dependencies is not exactly unheard of).
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_INVALID_FIELDS_TYPE', '[S] On field "T.g", for @requires(fields: f): Invalid value for argument "fields": must be a string.'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  it('rejects an invalid `fields` argument to @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: ":f") {
+        f: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_INVALID_FIELDS', '[S] On type "T", for @key(fields: ":f"): Syntax Error: Expected Name, found ":".'],
+    ]);
+  });
+
+  it('rejects an invalid `fields` argument to @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "{{f}}")
+      }
+
+      type T {
+        f: Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_INVALID_FIELDS', '[S] On field "Query.t", for @provides(fields: "{{f}}"): Syntax Error: Expected Name, found "{".'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  it('rejects an invalid `fields` argument to @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        f: Int @external
+        g: Int @requires(fields: "f b")
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_INVALID_FIELDS', '[S] On field "T.g", for @requires(fields: "f b"): Cannot query field "b" on type "T" (if the field is defined in another subgraph, you need to add it to this subgraph with @external).'],
+      ['EXTERNAL_UNUSED', '[S] Field "T.f" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface; the field declaration has no use and should be removed (or the field should not be @external).' ],
+    ]);
+  });
+
+  it('rejects @key on a list field', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "f") {
+        f: [Int]
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_FIELDS_SELECT_INVALID_TYPE', '[S] On type "T", for @key(fields: "f"): field "T.f" is a List type which is not allowed in @key'],
+    ]);
+  });
+
+  it('rejects @key on an interface field', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "f") {
+        f: I
+      }
+
+      interface I {
+        i: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_FIELDS_SELECT_INVALID_TYPE', '[S] On type "T", for @key(fields: "f"): field "T.f" is a Interface type which is not allowed in @key'],
+    ]);
+  });
+
+  it('rejects @key on an union field', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "f") {
+        f: U
+      }
+
+      union U = Query | T
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_FIELDS_SELECT_INVALID_TYPE', '[S] On type "T", for @key(fields: "f"): field "T.f" is a Union type which is not allowed in @key'],
+    ]);
+  });
+});
+
+describe('root types', () => {
+  it('rejects using Query as type name if not the query root', () => {
+    const subgraph =  gql`
+      schema {
+        query: MyQuery
+      }
+
+      type MyQuery {
+        f: Int
+      }
+
+      type Query {
+        g: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['ROOT_QUERY_USED', '[S] The schema has a type named "Query" but it is not set as the query root type ("MyQuery" is instead): this is not supported by federation. If a root type does not use its default name, there should be no other type with that default name.'],
+    ]);
+  });
+
+  it('rejects using Mutation as type name if not the mutation root', () => {
+    const subgraph =  gql`
+      schema {
+        mutation: MyMutation
+      }
+
+      type MyMutation {
+        f: Int
+      }
+
+      type Mutation {
+        g: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['ROOT_MUTATION_USED', '[S] The schema has a type named "Mutation" but it is not set as the mutation root type ("MyMutation" is instead): this is not supported by federation. If a root type does not use its default name, there should be no other type with that default name.'],
+    ]);
+  });
+
+  it('rejects using Subscription as type name if not the subscription root', () => {
+    const subgraph =  gql`
+      schema {
+        subscription: MySubscription
+      }
+
+      type MySubscription {
+        f: Int
+      }
+
+      type Subscription {
+        g: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['ROOT_SUBSCRIPTION_USED', '[S] The schema has a type named "Subscription" but it is not set as the subscription root type ("MySubscription" is instead): this is not supported by federation. If a root type does not use its default name, there should be no other type with that default name.'],
+    ]);
+  });
+});
+

package/src/debug.ts

@@ -1,24 +1,7 @@
 // Simple debugging facility.
 
 import chalk from 'chalk';
-
-function stringIsBoolean(str?: string) : boolean | undefined {
-  if (!str) {
-    return false;
-  }
-  switch (str.toLocaleLowerCase()) {
-    case "true":
-    case "yes":
-    case "1":
-      return true;
-    case "false":
-    case "no":
-    case "0":
-      return false;
-    default:
-      return undefined;
-  }
-}
+import { validateStringContainsBoolean } from './utils';
 
 function indentString(indentLevel: number) : string {
   let str = "";
@@ -30,7 +13,7 @@ function indentString(indentLevel: number) : string {
 
 function isEnabled(name: string): boolean {
   const v = process.env.APOLLO_FEDERATION_DEBUG;
-  const bool = stringIsBoolean(v);
+  const bool = validateStringContainsBoolean(v);
   if (bool !== undefined) {
     return bool;
   }

package/src/definitions.ts

@@ -697,6 +697,26 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
     return toReturn;
   }
 
+  /**
+   * Removes this this definition _and_, recursively, any other elements that references this type and would be invalid
+   * after the removal.
+   *
+   * Note that contrarily to `remove()` (which this method essentially call recursively), this method leaves the schema
+   * valid (assuming it was valid beforehand) _unless_ all the schema ends up being removed through recursion (in which
+   * case this leaves an empty schema, and that is not technically valid).
+   *
+   * Also note that this method does _not_ necessarily remove all the elements that reference this type: for instance,
+   * if this type is an interface, objects implementing it will _not_ be removed, they will simply stop implementing
+   * the interface. In practice, this method mainly remove fields that were using the removed type (in either argument or
+   * return type), but it can also remove object/input object/interface if through such field removal some type ends up
+   * empty, and it can remove unions if through that removal process and union becomes empty.
+   */
+  removeRecursive(): void {
+    this.remove().forEach(ref => this.removeReferenceRecursive(ref));
+  }
+
+  protected abstract removeReferenceRecursive(ref: TReferencer): void;
+
   referencers(): readonly TReferencer[] {
     return setValues(this._referencers);
   }
@@ -1530,6 +1550,10 @@ export class ScalarType extends BaseNamedType<OutputTypeReferencer | InputTypeRe
   protected removeInnerElements(): void {
     // No inner elements
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer | InputTypeReferencer): void {
+    ref.remove();
+  }
 }
 
 export class InterfaceImplementation<T extends ObjectType | InterfaceType> extends BaseExtensionMember<T> {
@@ -1753,6 +1777,20 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
     const schema = this.schema();
     return schema.schemaDefinition.root('query')?.type === this;
   }
+
+  protected removeReferenceRecursive(ref: ObjectTypeReferencer): void {
+    // Note that the ref can also be a`SchemaDefinition`, but don't have anything to do then.
+    switch (ref.kind) {
+      case 'FieldDefinition':
+        ref.removeRecursive();
+        break;
+      case 'UnionType':
+        if (ref.membersCount() === 0) {
+          ref.removeRecursive();
+        }
+        break;
+    }
+  }
 }
 
 export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeReferencer> {
@@ -1771,6 +1809,14 @@ export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeRe
     const typeName = typeof type === 'string' ? type : type.name;
     return this.possibleRuntimeTypes().some(t => t.name == typeName);
   }
+
+  protected removeReferenceRecursive(ref: InterfaceTypeReferencer): void {
+    // Note that an interface can be referenced by an object/interface that implements it, but after remove(), said object/interface
+    // will simply not implement "this" anymore and we have nothing more to do.
+    if (ref.kind === 'FieldDefinition') {
+      ref.removeRecursive();
+    }
+  }
 }
 
 export class UnionMember extends BaseExtensionMember<UnionType> {
@@ -1895,6 +1941,10 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
   protected hasNonExtensionInnerElements(): boolean {
     return this.members().some(m => m.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer): void {
+    ref.removeRecursive();
+  }
 }
 
 export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
@@ -1949,6 +1999,10 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   protected hasNonExtensionInnerElements(): boolean {
     return this._values.some(v => v.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer): void {
+    ref.removeRecursive();
+  }
 }
 
 export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObjectType> {
@@ -2019,6 +2073,19 @@ export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObj
   protected hasNonExtensionInnerElements(): boolean {
     return this.fields().some(f => f.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: InputTypeReferencer): void {
+    if (ref.kind === 'ArgumentDefinition') {
+      // Not only do we want to remove the argument, but we want to remove its parent. Technically, only removing the argument would
+      // leave the schema in a valid state so it would be an option, but this feel a bit too weird of a behaviour in practice for a
+      // method calling `removeRecursive`. And in particular, it would mean that if the argument is a directive definition one,
+      // we'd also have to update each of the directive application to remove the correspond argument. Removing the full directive
+      // definition (and all its applications) feels a bit more predictable.
+      ref.parent().removeRecursive();
+    } else {
+      ref.removeRecursive();
+    }
+  }
 }
 
 class BaseWrapperType<T extends Type> {
@@ -2192,6 +2259,19 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
     return [];
   }
 
+  /**
+   * Like `remove()`, but if this field was the last field of its parent type, the parent type is removed through its `removeRecursive` method.
+   */
+  removeRecursive(): void {
+    const parent = this._parent;
+    this.remove();
+    // Note that we exclude the union type here because it doesn't have the `fields()` method, but the only field unions can have is the __typename
+    // one and it cannot be removed, so remove() above will actually throw in practice before reaching this.
+    if (parent && !isUnionType(parent) && parent.fields().length === 0) {
+      parent.removeRecursive();
+    }
+  }
+
   toString(): string {
     const args = this._args.size == 0
       ? ""
@@ -2251,6 +2331,17 @@ export class InputFieldDefinition extends NamedSchemaElementWithType<InputType,
     return [];
   }
 
+  /**
+   * Like `remove()`, but if this field was the last field of its parent type, the parent type is removed through its `removeRecursive` method.
+   */
+  removeRecursive(): void {
+    const parent = this._parent;
+    this.remove();
+    if (parent && parent.fields().length === 0) {
+      parent.removeRecursive();
+    }
+  }
+
   toString(): string {
     const defaultStr = this.defaultValue === undefined ? "" : ` = ${valueToString(this.defaultValue, this.type)}`;
     return `${this.name}: ${this.type}${defaultStr}`;
@@ -2491,6 +2582,13 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     return toReturn;
   }
 
+  /**
+   * Removes this this directive definition _and_ all its applications.
+   */
+  removeRecursive(): void {
+    this.remove().forEach(ref => ref.remove());
+  }
+
   toString(): string {
     return `@${this.name}`;
   }