@apollo/federation-internals 2.1.0-alpha.1 → 2.1.0-alpha.4

package/src/__tests__/operations.test.ts

@@ -1,9 +1,12 @@
 import {
+  defaultRootName,
   Schema,
+  SchemaRootKind,
 } from '../../dist/definitions';
 import { buildSchema } from '../../dist/buildSchema';
 import { Field, FieldSelection, parseOperation, SelectionSet } from '../../dist/operations';
 import './matchers';
+import { GraphQLError } from 'graphql';
 
 function parseSchema(schema: string): Schema {
   try {
@@ -13,133 +16,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
+      }
+
+      fragment OnT2 on T2 {
+        x
+        y
+      }
+
+      fragment OnI on I {
+        b
+      }
 
-  const withoutFragments = parseOperation(schema, operation.toString(true, true));
-  expect(withoutFragments.toString()).toMatchString(`
-    {
-      t {
-        ... on T1 {
-          a
-          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
+          }
+        }
+        t2a {
+          ...OnT1
         }
-        u {
-          ... on U {
-            ... on I {
-              b
-            }
-            ... on T1 {
-              a
-              b
+      }
+    `);
+
+    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', () => {
@@ -259,3 +344,36 @@ describe('selection set freezing', () => {
     expect(s2.toString()).toBe('{ t { b } }');
   });
 });
+
+describe('validations', () => {
+  test.each([
+    { directive: '@defer', rootKind: 'mutation' },
+    { directive: '@defer', rootKind: 'subscription' },
+    { directive: '@stream', rootKind: 'mutation' },
+    { directive: '@stream', rootKind: 'subscription' },
+  ])('reject $directive on $rootKind type', ({ directive, rootKind }) => {
+    const schema = parseSchema(`
+      type Query {
+        x: String
+      }
+
+      type Mutation {
+        x: String
+      }
+
+      type Subscription {
+        x: String
+      }
+    `);
+
+    expect(() => {
+      parseOperation(schema, `
+        ${rootKind} {
+          ... ${directive} {
+            x
+          }
+        }
+      `)
+    }).toThrowError(new GraphQLError(`The @defer and @stream directives cannot be used on ${rootKind} root type "${defaultRootName(rootKind as SchemaRootKind)}"`));
+  });
+});

package/src/__tests__/subgraphValidation.test.ts

@@ -636,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

@@ -100,7 +100,7 @@ export function buildSchemaFromAST(
   // is that:
   // 1. we can (enum values are self-contained and cannot reference anything that may need to be imported first; this
   //   is also why we skip directive applications at that point, as those _may_ reference something that hasn't been imported yet)
-  // 2. this allows the code to handle better the case where the `link__Purpose` enum is provided in the AST despite the `@link` 
+  // 2. this allows the code to handle better the case where the `link__Purpose` enum is provided in the AST despite the `@link`
   //   _definition_ not being provided. And the reason that is true is that as we later _add_ the `@link` definition, we
   //   will need to check if `link_Purpose` needs to be added or not, but when it is already present, we check it's definition
   //   is the expected, but that check will unexpected fail if we haven't finished "building" said type definition.
@@ -215,7 +215,7 @@ function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema:
         let type = schema.type(definitionNode.name.value);
         // Note that the type may already exists due to an extension having been processed first, but we know we
         // have seen 2 definitions (which is invalid) if the definition has `preserverEmptyDefnition` already set
-        // since it's only set for definitions, not extensions. 
+        // since it's only set for definitions, not extensions.
         // Also note that we allow to redefine built-ins.
         if (!type || type.isBuiltIn) {
           type = schema.addType(newNamedType(withoutTrailingDefinition(definitionNode.kind), definitionNode.name.value));
@@ -332,9 +332,23 @@ function buildAppliedDirectives(
   for (const directive of elementNode.directives ?? []) {
     withNodeAttachedToError(
       () => {
-        const d = element.applyDirective(directive.name.value, buildArgs(directive));
-        d.setOfExtension(extension);
-        d.sourceAST = directive;
+        /**
+         * If we are at the schemaDefinition level of a federation schema, it's possible that some directives
+         * will not be added until after the federation calls completeSchema. In that case, we want to wait
+         * until after completeSchema is called before we try to apply those directives.
+         */
+        if (element !== element.schema().schemaDefinition || directive.name.value === 'link' || !element.schema().blueprint.applyDirectivesAfterParsing()) {
+          const d = element.applyDirective(directive.name.value, buildArgs(directive));
+          d.setOfExtension(extension);
+          d.sourceAST = directive;
+        } else {
+          element.addUnappliedDirective({
+            extension,
+            directive,
+            args: buildArgs(directive),
+            nameOrDef: directive.name.value,
+          });
+        }
       },
       directive,
       errors,