@apollo/federation-internals 2.1.0-alpha.2 → 2.1.0

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 {
@@ -341,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__/removeInaccessibleElements.test.ts

@@ -1,6 +1,5 @@
 import {
   ArgumentDefinition,
-  errorCauses,
   FieldDefinition,
   InterfaceType,
   ObjectType,
@@ -8,8 +7,8 @@ import {
 } from "../definitions";
 import { buildSchema } from "../buildSchema";
 import { removeInaccessibleElements } from "../inaccessibleSpec";
-import { GraphQLErrorExt } from "@apollo/core-schema/dist/error";
 import { GraphQLError } from "graphql";
+import { errorCauses } from "../error";
 
 describe("removeInaccessibleElements", () => {
   const INACCESSIBLE_V02_HEADER = `
@@ -31,7 +30,6 @@ describe("removeInaccessibleElements", () => {
   `;
 
   function getCauses(e: unknown): GraphQLError[] {
-    expect(e instanceof GraphQLErrorExt).toBeTruthy();
     const causes = errorCauses(e as Error);
     expect(causes).toBeDefined();
     expect(Array.isArray(causes)).toBeTruthy();

package/src/__tests__/schemaUpgrader.test.ts

@@ -167,7 +167,6 @@ test('update federation directive non-string arguments', () => {
   `);
 })
 
-
 test('remove tag on external field if found on definition', () => {
   const s1 = `
     type Query {

package/src/__tests__/subgraphValidation.test.ts

@@ -1,7 +1,6 @@
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
-import { Subgraph } from '..';
-import { errorCauses } from '../definitions';
+import { Subgraph, errorCauses } from '..';
 import { asFed2SubgraphDocument, buildSubgraph } from "../federation"
 import { defaultPrintOptions, printSchema } from '../print';
 import './matchers';

package/src/buildSchema.ts

@@ -52,10 +52,9 @@ import {
   EnumType,
   Extension,
   ErrGraphQLValidationFailed,
-  errorCauses,
   NamedSchemaElement,
 } from "./definitions";
-import { ERRORS, withModifiedErrorNodes } from "./error";
+import { ERRORS, errorCauses, withModifiedErrorNodes } from "./error";
 
 function buildValue(value?: ValueNode): any {
   return value ? valueFromASTUntyped(value) : undefined;
@@ -100,7 +99,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 +214,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 +331,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,

package/src/coreSpec.ts

@@ -2,9 +2,8 @@ import { ASTNode, DirectiveLocation, GraphQLError, StringValueNode } from "graph
 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 { err } from '@apollo/core-schema';
 import { assert, firstOf } from './utils';
-import { ERRORS } from "./error";
+import { aggregateError, ERRORS } from "./error";
 import { valueToString } from "./values";
 import { coreFeatureDefinitionIfKnown, registerKnownFeature } from "./knownCoreFeatures";
 import { didYouMean, suggestionList } from "./suggestions";
@@ -15,11 +14,7 @@ export const linkIdentity = 'https://specs.apollo.dev/link';
 
 export const linkDirectiveDefaultName = 'link';
 
-export const ErrCoreCheckFailed = (causes: Error[]) =>
-  err('CheckFailed', {
-    message: 'one or more checks failed',
-    causes
-  })
+export const ErrCoreCheckFailed = (causes: GraphQLError[]) => aggregateError('CheckFailed', 'one or more checks failed', causes);
 
 function buildError(message: string): Error {
   // Maybe not the right error for this?