@apollo/federation-internals 2.0.6-rc.1 → 2.1.0-alpha.2

package/src/__tests__/operations.test.ts

@@ -13,133 +13,215 @@ function parseSchema(schema: string): Schema {
   }
 }
 
-test('fragments optimization of selection sets', () => {
-  const schema = parseSchema(`
-    type Query {
-      t: T1
-    }
-
-    interface I {
-      b: Int
-    }
+describe('fragments optimization', () => {
+  test('handles fragments using other fragments', () => {
+    const schema = parseSchema(`
+      type Query {
+        t: T1
+      }
 
-    type T1 {
-      a: Int
-      b: Int
-      u: U
-    }
+      interface I {
+        b: Int
+      }
 
-    type T2 {
-      x: String
-      y: String
-      b: Int
-      u: U
-    }
+      type T1 {
+        a: Int
+        b: Int
+        u: U
+      }
 
-    union U = T1 | T2
-  `);
+      type T2 {
+        x: String
+        y: String
+        b: Int
+        u: U
+      }
 
-  const operation = parseOperation(schema, `
-    fragment OnT1 on T1 {
-      a
-      b
-    }
+      union U = T1 | T2
+    `);
 
-    fragment OnT2 on T2 {
-      x
-      y
-    }
+    const operation = parseOperation(schema, `
+      fragment OnT1 on T1 {
+        a
+        b
+      }
 
-    fragment OnI on I {
-      b
-    }
+      fragment OnT2 on T2 {
+        x
+        y
+      }
 
-    fragment OnU on U {
-      ...OnI
-      ...OnT1
-      ...OnT2
-    }
+      fragment OnI on I {
+        b
+      }
 
-    query {
-      t {
+      fragment OnU on U {
+        ...OnI
         ...OnT1
         ...OnT2
-        ...OnI
-        u {
-          ...OnU
+      }
+
+      query {
+        t {
+          ...OnT1
+          ...OnT2
+          ...OnI
+          u {
+            ...OnU
+          }
         }
       }
-    }
-  `);
+    `);
+
+    const withoutFragments = parseOperation(schema, operation.toString(true, true));
+    expect(withoutFragments.toString()).toMatchString(`
+      {
+        t {
+          ... on T1 {
+            a
+            b
+          }
+          ... on T2 {
+            x
+            y
+          }
+          ... on I {
+            b
+          }
+          u {
+            ... on U {
+              ... on I {
+                b
+              }
+              ... on T1 {
+                a
+                b
+              }
+              ... on T2 {
+                x
+                y
+              }
+            }
+          }
+        }
+      }
+    `);
+
+    const optimized = withoutFragments.optimize(operation.selectionSet.fragments!);
+    // Note that we expect onU to *not* be recreated because, by default, optimize only
+    // add add back a fragment if it is used at least twice (otherwise, the fragment just
+    // make the query bigger).
+    expect(optimized.toString()).toMatchString(`
+      fragment OnT1 on T1 {
+        a
+        b
+      }
 
-  const withoutFragments = parseOperation(schema, operation.toString(true, true));
-  expect(withoutFragments.toString()).toMatchString(`
-    {
-      t {
-        ... on T1 {
-          a
-          b
+      fragment OnT2 on T2 {
+        x
+        y
+      }
+
+      fragment OnI on I {
+        b
+      }
+
+      {
+        t {
+          ...OnT1
+          ...OnT2
+          ...OnI
+          u {
+            ...OnI
+            ...OnT1
+            ...OnT2
+          }
         }
-        ... on T2 {
+      }
+    `);
+  });
+
+  test('handles fragments with nested selections', () => {
+    const schema = parseSchema(`
+      type Query {
+        t1a: T1
+        t2a: T1
+      }
+
+      type T1 {
+        t2: T2
+      }
+
+      type T2 {
+        x: String
+        y: String
+      }
+    `);
+
+    const operation = parseOperation(schema, `
+      fragment OnT1 on T1 {
+        t2 {
           x
-          y
         }
-        ... on I {
-          b
+      }
+
+      query {
+        t1a {
+          ...OnT1
+          t2 {
+            y
+          }
         }
-        u {
-          ... on U {
-            ... on I {
-              b
-            }
-            ... on T1 {
-              a
-              b
+        t2a {
+          ...OnT1
+        }
+      }
+    `);
+
+    const withoutFragments = parseOperation(schema, operation.toString(true, true));
+    expect(withoutFragments.toString()).toMatchString(`
+      {
+        t1a {
+          ... on T1 {
+            t2 {
+              x
             }
-            ... on T2 {
+          }
+          t2 {
+            y
+          }
+        }
+        t2a {
+          ... on T1 {
+            t2 {
               x
-              y
             }
           }
         }
       }
-    }
-  `);
+    `);
 
-  const optimized = withoutFragments.optimize(operation.selectionSet.fragments!);
-  // Note that we expect onU to *not* be recreated because, by default, optimize only
-  // add add back a fragment if it is used at least twice (otherwise, the fragment just
-  // make the query bigger).
-  expect(optimized.toString()).toMatchString(`
-    fragment OnT1 on T1 {
-      a
-      b
-    }
-
-    fragment OnT2 on T2 {
-      x
-      y
-    }
-
-    fragment OnI on I {
-      b
-    }
+    const optimized = withoutFragments.optimize(operation.selectionSet.fragments!);
+    expect(optimized.toString()).toMatchString(`
+      fragment OnT1 on T1 {
+        t2 {
+          x
+        }
+      }
 
-    {
-      t {
-        ...OnT1
-        ...OnT2
-        ...OnI
-        u {
-          ... on U {
-            ...OnI
-            ...OnT1
-            ...OnT2
+      {
+        t1a {
+          ...OnT1
+          t2 {
+            y
           }
         }
+        t2a {
+          ...OnT1
+        }
       }
-    }
-  `);
+    `);
+  });
 });
 
 describe('selection set freezing', () => {

package/src/__tests__/subgraphValidation.test.ts

@@ -385,6 +385,81 @@ describe('fieldset-based directives', () => {
       ['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'],
     ]);
   });
+
+  it('rejects directive applications in @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "v { x ... @include(if: false) { y }}") {
+        v: V
+      }
+
+      type V {
+        x: Int
+        y: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['KEY_DIRECTIVE_IN_FIELDS_ARG', '[S] On type "T", for @key(fields: "v { x ... @include(if: false) { y }}"): cannot have directive applications in the @key(fields:) argument but found @include(if: false).'],
+    ]);
+  });
+
+  it('rejects directive applications in @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "v { ... on V @skip(if: true) { x y } }")
+      }
+
+      type T @key(fields: "id") {
+        id: ID
+        v: V @external
+      }
+
+      type V {
+        x: Int
+        y: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_DIRECTIVE_IN_FIELDS_ARG', '[S] On field "Query.t", for @provides(fields: "v { ... on V @skip(if: true) { x y } }"): cannot have directive applications in the @provides(fields:) argument but found @skip(if: true).'],
+    ]);
+  });
+
+  it('rejects directive applications in @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "id") {
+        id: ID
+        a: Int @requires(fields: "... @skip(if: false) { b }")
+        b: Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['REQUIRES_DIRECTIVE_IN_FIELDS_ARG', '[S] On field "T.a", for @requires(fields: "... @skip(if: false) { b }"): cannot have directive applications in the @requires(fields:) argument but found @skip(if: false).'],
+    ]);
+  });
+
+  it('can collect multiple errors in a single `fields` argument', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "f(x: 3)")
+      }
+
+      type T @key(fields: "id") {
+        id: ID
+        f(x: Int): Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      ['PROVIDES_FIELDS_HAS_ARGS', '[S] On field "Query.t", for @provides(fields: "f(x: 3)"): field T.f cannot be included because it has arguments (fields with argument are not allowed in @provides)'],
+      ['PROVIDES_FIELDS_MISSING_EXTERNAL', '[S] On field "Query.t", for @provides(fields: "f(x: 3)"): field "T.f" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)'],
+    ]);
+  });
 });
 
 describe('root types', () => {
@@ -561,6 +636,8 @@ describe('@core/@link handling', () => {
 
     directive @federation__override(from: String!) on FIELD_DEFINITION
 
+    directive @federation__composeDirective(name: String) repeatable on SCHEMA
+
     type T
       @key(fields: "k")
     {

package/src/buildSchema.ts

@@ -55,6 +55,7 @@ import {
   errorCauses,
   NamedSchemaElement,
 } from "./definitions";
+import { ERRORS, withModifiedErrorNodes } from "./error";
 
 function buildValue(value?: ValueNode): any {
   return value ? valueFromASTUntyped(value) : undefined;
@@ -195,7 +196,7 @@ function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema:
     switch (definitionNode.kind) {
       case 'OperationDefinition':
       case 'FragmentDefinition':
-        errors.push(new GraphQLError("Invalid executable definition found while building schema", definitionNode));
+        errors.push(ERRORS.INVALID_GRAPHQL.err("Invalid executable definition found while building schema", { nodes: definitionNode }));
         continue;
       case 'SchemaDefinition':
         schemaDefinitions.push(definitionNode);
@@ -220,7 +221,7 @@ function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema:
           type = schema.addType(newNamedType(withoutTrailingDefinition(definitionNode.kind), definitionNode.name.value));
         } else if (type.preserveEmptyDefinition)  {
           // Note: we reuse the same error message than graphQL-js would output
-          throw new GraphQLError(`There can be only one type named "${definitionNode.name.value}"`);
+          throw ERRORS.INVALID_GRAPHQL.err(`There can be only one type named "${definitionNode.name.value}"`);
         }
         // It's possible for the type definition to be empty, because it is valid graphQL to have:
         //   type Foo
@@ -251,7 +252,7 @@ function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema:
         if (!existing) {
           schema.addType(newNamedType(withoutTrailingDefinition(definitionNode.kind), definitionNode.name.value));
         } else if (existing.isBuiltIn) {
-          throw new GraphQLError(`Cannot extend built-in type "${definitionNode.name.value}"`);
+          throw ERRORS.INVALID_GRAPHQL.err(`Cannot extend built-in type "${definitionNode.name.value}"`);
         }
         break;
       case 'DirectiveDefinition':
@@ -281,7 +282,7 @@ function withoutTrailingDefinition(str: string): NamedTypeKind {
 function getReferencedType(node: NamedTypeNode, schema: Schema): NamedType {
   const type = schema.type(node.name.value);
   if (!type) {
-    throw new GraphQLError(`Unknown type ${node.name.value}`, node);
+    throw ERRORS.INVALID_GRAPHQL.err(`Unknown type ${node.name.value}`, { nodes: node });
   }
   return type;
 }
@@ -294,15 +295,7 @@ function withNodeAttachedToError(operation: () => void, node: ASTNode, errors: G
     if (causes) {
       for (const cause of causes) {
         const allNodes: ASTNode | ASTNode[] = cause.nodes ? [node, ...cause.nodes] : node;
-        errors.push(new GraphQLError(
-          cause.message,
-          allNodes,
-          cause.source,
-          cause.positions,
-          cause.path,
-          cause,
-          cause.extensions
-        ));
+        errors.push(withModifiedErrorNodes(cause, allNodes));
       }
     } else {
       throw e;
@@ -392,7 +385,7 @@ function buildNamedTypeInner(
           () => {
             const itfName = itfNode.name.value;
             if (fieldBasedType.implementsInterface(itfName)) {
-              throw new GraphQLError(`Type "${type}" can only implement "${itfName}" once.`);
+              throw ERRORS.INVALID_GRAPHQL.err(`Type "${type}" can only implement "${itfName}" once.`);
             }
             fieldBasedType.addImplementedInterface(itfName).setOfExtension(extension);
           },
@@ -409,7 +402,7 @@ function buildNamedTypeInner(
           () => {
             const name = namedType.name.value;
             if (unionType.hasTypeMember(name)) {
-              throw new GraphQLError(`Union type "${unionType}" can only include type "${name}" once.`);
+              throw ERRORS.INVALID_GRAPHQL.err(`Union type "${unionType}" can only include type "${name}" once.`);
             }
             unionType.addType(name).setOfExtension(extension);
           },
@@ -477,7 +470,7 @@ function validateOutputType(type: Type, what: string, node: ASTNode, errors: Gra
   if (isOutputType(type)) {
     return type;
   } else {
-    errors.push(new GraphQLError(`The type of "${what}" must be Output Type but got "${type}", a ${type.kind}.`, node));
+    errors.push(ERRORS.INVALID_GRAPHQL.err(`The type of "${what}" must be Output Type but got "${type}", a ${type.kind}.`, { nodes: node }));
     return undefined;
   }
 }
@@ -486,7 +479,7 @@ function validateInputType(type: Type, what: string, node: ASTNode, errors: Grap
   if (isInputType(type)) {
     return type;
   } else {
-    errors.push(new GraphQLError(`The type of "${what}" must be Input Type but got "${type}", a ${type.kind}.`, node));
+    errors.push(ERRORS.INVALID_GRAPHQL.err(`The type of "${what}" must be Input Type but got "${type}", a ${type.kind}.`, { nodes: node }));
     return undefined;
   }
 }
@@ -502,7 +495,7 @@ function buildTypeReferenceFromAST(typeNode: TypeNode, schema: Schema): Type {
     case Kind.NON_NULL_TYPE:
       const wrapped = buildTypeReferenceFromAST(typeNode.type, schema);
       if (wrapped.kind == Kind.NON_NULL_TYPE) {
-        throw new GraphQLError(`Cannot apply the non-null operator (!) twice to the same type`, typeNode);
+        throw ERRORS.INVALID_GRAPHQL.err(`Cannot apply the non-null operator (!) twice to the same type`, { nodes: typeNode });
       }
       return new NonNullType(wrapped);
     default:

package/src/coreSpec.ts

@@ -1,6 +1,6 @@
 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 } from "./definitions";
+import { CoreFeature, Directive, DirectiveDefinition, EnumType, ErrGraphQLAPISchemaValidationFailed, ErrGraphQLValidationFailed, InputType, ListType, NamedType, NonNullType, ScalarType, Schema, SchemaDefinition, SchemaElement, sourceASTs } from "./definitions";
 import { sameType } from "./types";
 import { err } from '@apollo/core-schema';
 import { assert, firstOf } from './utils';
@@ -185,10 +185,10 @@ export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<
       continue;
     }
     if (typeof elt !== 'object') {
-      errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-        message: `Invalid sub-value ${valueToString(elt)} for @link(import:) argument: values should be either strings or input object values of the form { name: "<importedElement>", as: "<alias>" }.`,
-        nodes: directive.sourceAST
-      }));
+      errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+        `Invalid sub-value ${valueToString(elt)} for @link(import:) argument: values should be either strings or input object values of the form { name: "<importedElement>", as: "<alias>" }.`,
+        { nodes: directive.sourceAST },
+      ));
       continue;
     }
     let name: string | undefined;
@@ -196,28 +196,28 @@ export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<
       switch (key) {
         case 'name':
           if (typeof value !== 'string') {
-            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-              message: `Invalid value for the "name" field for sub-value ${valueToString(elt)} of @link(import:) argument: must be a string.`,
-              nodes: directive.sourceAST
-            }));
+            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+              `Invalid value for the "name" field for sub-value ${valueToString(elt)} of @link(import:) argument: must be a string.`,
+              { nodes: directive.sourceAST },
+            ));
             continue importArgLoop;
           }
           name = value;
           break;
         case 'as':
           if (typeof value !== 'string') {
-            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-              message: `Invalid value for the "as" field for sub-value ${valueToString(elt)} of @link(import:) argument: must be a string.`,
-              nodes: directive.sourceAST
-            }));
+            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+              `Invalid value for the "as" field for sub-value ${valueToString(elt)} of @link(import:) argument: must be a string.`,
+              { nodes: directive.sourceAST },
+            ));
             continue importArgLoop;
           }
           break;
         default:
-          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-            message: `Unknown field "${key}" for sub-value ${valueToString(elt)} of @link(import:) argument.`,
-            nodes: directive.sourceAST
-          }));
+          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+            `Unknown field "${key}" for sub-value ${valueToString(elt)} of @link(import:) argument.`,
+            { nodes: directive.sourceAST },
+          ));
           continue importArgLoop;
       }
     }
@@ -226,24 +226,24 @@ export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<
       imports.push(i);
       if (i.as) {
         if (i.name.charAt(0) === '@' && i.as.charAt(0) !== '@') {
-          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-            message: `Invalid @link import renaming: directive "${i.name}" imported name should start with a '@' character, but got "${i.as}".`,
-            nodes: directive.sourceAST
-          }));
+          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+            `Invalid @link import renaming: directive "${i.name}" imported name should start with a '@' character, but got "${i.as}".`,
+            { nodes: directive.sourceAST },
+          ));
         }
         else if (i.name.charAt(0) !== '@' && i.as.charAt(0) === '@') {
-          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-            message: `Invalid @link import renaming: type "${i.name}" imported name should not start with a '@' character, but got "${i.as}" (or, if @${i.name} is a directive, then it should be referred to with a '@').`,
-            nodes: directive.sourceAST
-          }));
+          errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+            `Invalid @link import renaming: type "${i.name}" imported name should not start with a '@' character, but got "${i.as}" (or, if @${i.name} is a directive, then it should be referred to with a '@').`,
+            { nodes: directive.sourceAST },
+          ));
         }
       }
       validateImportedName(name, knownElements, errors, directive);
     } else {
-      errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-        message: `Invalid sub-value ${valueToString(elt)} for @link(import:) argument: missing mandatory "name" field.`,
-        nodes: directive.sourceAST
-      }));
+      errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+        `Invalid sub-value ${valueToString(elt)} for @link(import:) argument: missing mandatory "name" field.`,
+        { nodes: directive.sourceAST },
+      ));
     }
   }
 
@@ -264,10 +264,10 @@ function validateImportedName(name: string, knownElements: string[] | undefined,
         details = didYouMean(suggestions);
       }
     }
-    errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-      message: `Cannot import unknown element "${name}".${details}`,
-      nodes: directive.sourceAST
-    }));
+    errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+      `Cannot import unknown element "${name}".${details}`,
+      { nodes: directive.sourceAST },
+    ));
   }
 }
 
@@ -419,9 +419,9 @@ export class CoreSpecDefinition extends FeatureDefinition {
         // Already exists with the same version, let it be.
         return [];
       } else {
-        return [ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err({
-          message: `Cannot add feature ${this} to the schema, it already uses ${existingCore.coreItself.url}`
-        })];
+        return [ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+          `Cannot add feature ${this} to the schema, it already uses ${existingCore.coreItself.url}`
+        )];
       }
     }
 
@@ -555,7 +555,7 @@ export class FeatureVersion {
   public static parse(input: string): FeatureVersion {
     const match = input.match(this.VERSION_RE)
     if (!match) {
-      throw new GraphQLError(`Expected a version string (of the form v1.2), got ${input}`);
+      throw ERRORS.INVALID_LINK_IDENTIFIER.err(`Expected a version string (of the form v1.2), got ${input}`);
     }
     return new this(+match[1], +match[2])
   }
@@ -663,17 +663,17 @@ export class FeatureUrl {
   public static parse(input: string, node?: ASTNode): FeatureUrl {
     const url = new URL(input)
     if (!url.pathname || url.pathname === '/') {
-      throw new GraphQLError(`Missing path in feature url '${url}'`, node)
+      throw ERRORS.INVALID_LINK_IDENTIFIER.err(`Missing path in feature url '${url}'`, { nodes: node })
     }
     const path = url.pathname.split('/')
     const verStr = path.pop()
     if (!verStr) {
-      throw new GraphQLError(`Missing version component in feature url '${url}'`, node)
+      throw ERRORS.INVALID_LINK_IDENTIFIER.err(`Missing version component in feature url '${url}'`, { nodes: node })
     }
     const version = FeatureVersion.parse(verStr)
     const name = path[path.length - 1]
     if (!name) {
-      throw new GraphQLError(`Missing feature name component in feature url '${url}'`, node)
+      throw ERRORS.INVALID_LINK_IDENTIFIER.err(`Missing feature name component in feature url '${url}'`, { nodes: node })
     }
     const element = url.hash ? url.hash.slice(1): undefined
     url.hash = ''
@@ -804,11 +804,15 @@ export function removeAllCoreFeatures(schema: Schema) {
   for (const { feature, type, references } of typeReferences) {
     const referencesInSchema = references.filter(r => r.isAttached());
     if (referencesInSchema.length > 0) {
-      errors.push(new GraphQLError(
+      // Note: using REFERENCED_INACCESSIBLE is slightly abusive because the reference element is not marked
+      // @inacessible exactly. Instead, it is inacessible due to core elements being removed, but that's very
+      // very close semantically. Overall, adding a publicly documented error code just to minor difference
+      // doesn't feel worth it, especially since that case is super unlikely in the first place (and, as
+      // the prior comment says, may one day be removed too).
+      errors.push(ERRORS.REFERENCED_INACCESSIBLE.err(
         `Cannot remove elements of feature ${feature} as feature type ${type}` +
         ` is referenced by elements: ${referencesInSchema.join(', ')}`,
-        references.map(r => r.sourceAST)
-          .filter(n => n !== undefined) as ASTNode[]
+        { nodes: sourceASTs(...references) },
       ));
     }
   }