@apollo/federation-internals 2.0.0-alpha.0 → 2.0.0-alpha.4

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 as string, 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/__tests__/utils.test.ts

@@ -0,0 +1,92 @@
+import { OrderedMap } from '../utils';
+
+describe('OrderedMap', () => {
+  it('updating value works', () => {
+    const orderedMap = new OrderedMap<string, number>();
+    orderedMap.add('one', 0);
+    expect(orderedMap.get('one')).toBe(0);
+    expect(orderedMap.size).toBe(1);
+
+    orderedMap.add('one', 1);
+    expect(orderedMap.get('one')).toBe(1);
+    expect(orderedMap.size).toBe(1);
+    expect(orderedMap.keys()).toEqual(['one']);
+    expect(orderedMap.values()).toEqual([1]);
+  });
+
+  it('test lexicographical sorting of map (default sorting algorithm)', () => {
+    const orderedMap = new OrderedMap<string, number>();
+    orderedMap.add('one', 1);
+    orderedMap.add('two', 2);
+    orderedMap.add('three', 3);
+    orderedMap.add('four', 4);
+    orderedMap.add('five', 5);
+    orderedMap.add('six', 6);
+    orderedMap.add('seven', 7);
+    orderedMap.add('eight', 8);
+    orderedMap.add('nine', 9);
+
+    // keys are in alphabetical order
+    expect(orderedMap.keys()).toEqual(['eight', 'five', 'four', 'nine', 'one', 'seven', 'six', 'three', 'two']);
+    const sortedArr = [8,5,4,9,1,7,6,3,2];
+    expect(orderedMap.values()).toEqual(sortedArr);
+
+    // test using spread operator to make sure iterator is performing correctly
+    expect([...orderedMap]).toEqual(sortedArr);
+
+    // testing get function
+    expect(orderedMap.get('one')).toBe(1);
+    expect(orderedMap.get('ten')).toBeUndefined();
+
+    // testing size function
+    expect(orderedMap.size).toBe(9);
+    orderedMap.add('one', 1);
+    expect(orderedMap.size).toBe(9);
+    expect(orderedMap.values()).toEqual(sortedArr);
+
+    // has function
+    expect(orderedMap.has('one')).toBe(true);
+    expect(orderedMap.has('fifty')).toBe(false);
+  });
+
+  it('sort by string length', () => {
+    const orderedMap = new OrderedMap<string, number>((a: string, b: string) => {
+      if (a.length < b.length) {
+        return -1;
+      } else if (b.length < a.length) {
+        return 1;
+      }
+      return 0;
+    });
+    orderedMap.add('eight', 8);
+    orderedMap.add('seventy', 70);
+    orderedMap.add('six', 6);
+    orderedMap.add('four', 4);
+
+    expect(orderedMap.keys()).toEqual(['six', 'four', 'eight', 'seventy']);
+    const sortedArr = [6,4,8,70];
+    expect(orderedMap.values()).toEqual(sortedArr);
+
+    // test using spread operator to make sure iterator is performing correctly
+    expect([...orderedMap]).toEqual(sortedArr);
+  });
+
+  it('sort numerically', () => {
+    const orderedMap = new OrderedMap<number, number>();
+    orderedMap.add(4, 40);
+    orderedMap.add(1, 10);
+    orderedMap.add(7, 70);
+    orderedMap.add(2, 20);
+    orderedMap.add(6, 60);
+    orderedMap.add(3, 30);
+    orderedMap.add(9, 90);
+    orderedMap.add(5, 50);
+    orderedMap.add(8, 80);
+
+    const keys = [1,2,3,4,5,6,7,8,9];
+    const values = [10,20,30,40,50,60,70,80,90];
+    expect(orderedMap.keys()).toEqual(keys);
+    expect(orderedMap.values()).toEqual(values);
+    expect([...orderedMap]).toEqual(values);
+  });
+});

package/src/buildSchema.ts

@@ -1,7 +1,7 @@
 import {
   DefinitionNode,
   DirectiveDefinitionNode,
-  DirectiveLocationEnum,
+  DirectiveLocation,
   DirectiveNode,
   DocumentNode,
   FieldDefinitionNode,
@@ -18,7 +18,8 @@ import {
   StringValueNode,
   ASTNode,
   SchemaExtensionNode,
-  parseType
+  parseType,
+  Kind,
 } from "graphql";
 import { Maybe } from "graphql/jsutils/Maybe";
 import {
@@ -57,7 +58,7 @@ function buildValue(value?: ValueNode): any {
   //   - for ID, which accepts strings and int, we don't get int converted to string.
   //   - for floats, we get either int or float, we don't get int converted to float.
   //   - we don't get any custom coercion (but neither is buildSchema in graphQL-js anyway).
-  // 2) type validation. 
+  // 2) type validation.
   return value ? valueFromASTUntyped(value) : undefined;
 }
 
@@ -91,7 +92,7 @@ export function buildSchemaFromAST(documentNode: DocumentNode, builtIns: BuiltIn
       case 'SchemaExtension':
         buildSchemaDefinitionInner(
           definitionNode,
-          schema.schemaDefinition, 
+          schema.schemaDefinition,
           schema.schemaDefinition.newExtension());
         break;
       case 'ScalarTypeDefinition':
@@ -300,7 +301,7 @@ function buildNamedTypeInner(
 }
 
 function buildFieldDefinitionInner(fieldNode: FieldDefinitionNode, field: FieldDefinition<any>) {
-  const type = buildTypeReferenceFromAST(fieldNode.type, field.schema()!);
+  const type = buildTypeReferenceFromAST(fieldNode.type, field.schema());
   field.type = ensureOutputType(type, field.coordinate, fieldNode);
   for (const inputValueDef of fieldNode.arguments ?? []) {
     buildArgumentDefinitionInner(inputValueDef, field.addArgument(inputValueDef.name.value));
@@ -332,11 +333,11 @@ export function builtTypeReference(encodedType: string, schema: Schema): Type {
 
 function buildTypeReferenceFromAST(typeNode: TypeNode, schema: Schema): Type {
   switch (typeNode.kind) {
-    case 'ListType':
+    case Kind.LIST_TYPE:
       return new ListType(buildTypeReferenceFromAST(typeNode.type, schema));
-    case 'NonNullType':
+    case Kind.NON_NULL_TYPE:
       const wrapped = buildTypeReferenceFromAST(typeNode.type, schema);
-      if (wrapped.kind == 'NonNullType') {
+      if (wrapped.kind == Kind.NON_NULL_TYPE) {
         throw new GraphQLError(`Cannot apply the non-null operator (!) twice to the same type`, typeNode);
       }
       return new NonNullType(wrapped);
@@ -346,7 +347,7 @@ function buildTypeReferenceFromAST(typeNode: TypeNode, schema: Schema): Type {
 }
 
 function buildArgumentDefinitionInner(inputNode: InputValueDefinitionNode, arg: ArgumentDefinition<any>) {
-  const type = buildTypeReferenceFromAST(inputNode.type, arg.schema()!);
+  const type = buildTypeReferenceFromAST(inputNode.type, arg.schema());
   arg.type = ensureInputType(type, arg.coordinate, inputNode);
   arg.defaultValue = buildValue(inputNode.defaultValue);
   buildAppliedDirectives(inputNode, arg);
@@ -355,7 +356,7 @@ function buildArgumentDefinitionInner(inputNode: InputValueDefinitionNode, arg:
 }
 
 function buildInputFieldDefinitionInner(fieldNode: InputValueDefinitionNode, field: InputFieldDefinition) {
-  const type = buildTypeReferenceFromAST(fieldNode.type, field.schema()!);
+  const type = buildTypeReferenceFromAST(fieldNode.type, field.schema());
   field.type = ensureInputType(type, field.coordinate, fieldNode);
   field.defaultValue = buildValue(fieldNode.defaultValue);
   buildAppliedDirectives(fieldNode, field);
@@ -368,7 +369,7 @@ function buildDirectiveDefinitionInner(directiveNode: DirectiveDefinitionNode, d
     buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value));
   }
   directive.repeatable = directiveNode.repeatable;
-  const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocationEnum);
+  const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocation);
   directive.addLocations(...locations);
   directive.description = directiveNode.description?.value;
   directive.sourceAST = directiveNode;