@apollo/federation-internals 2.0.0-alpha.6 → 2.0.0-preview.2

package/src/__tests__/schemaUpgrader.test.ts

@@ -0,0 +1,168 @@
+import { buildSubgraph, Subgraphs } from '../federation';
+import { UpgradeChangeID, UpgradeResult, upgradeSubgraphsIfNecessary } from '../schemaUpgrader';
+import './matchers';
+
+function changeMessages(res: UpgradeResult, subgraphName: string, id: UpgradeChangeID): string[] {
+  const changes = res.changes?.get(subgraphName)?.get(id);
+  return changes?.map(c => c.toString()) ?? [];
+}
+
+/**
+ * A lot of the schema upgrader behaviors are tested as part of composing fed1 schema in `composeFed1Subgraphs.test.ts`.
+ * This test file thus mostly focuses on the change-reporting of the schema upgrader.
+ */
+
+test('upgrade complex schema', () => {
+  const s1 = `
+    type Query {
+      products: [Product!]! @provides(fields: "upc description")
+    }
+
+    interface I @key(fields: "upc") {
+      upc: ID!
+      description: String @external
+    }
+
+    extend type Product implements I @key(fields: "upc") {
+      upc: ID! @external
+      name: String @external
+      inventory: Int @requires(fields: "upc")
+      description: String @external
+    }
+
+    # A type with a genuine 'graphqQL' extension, to ensure the extend don't get removed.
+    type Random {
+      x: Int @provides(fields: "x")
+    }
+
+    extend type Random {
+      y: Int
+    }
+  `;
+
+  // Note that no changes are really expected on that 2nd schema: it is just there to make the example not throw due to
+  // then Product type extension having no "base".
+  const s2 = `
+    type Product @key(fields: "upc") {
+      upc: ID!
+      name: String
+      description: String
+    }
+  `;
+
+  const subgraphs = new Subgraphs();
+  subgraphs.add(buildSubgraph('s1', 'http://s1', s1));
+  subgraphs.add(buildSubgraph('s2', 'http://s1', s2));
+  const res = upgradeSubgraphsIfNecessary(subgraphs);
+  expect(res.errors).toBeUndefined();
+
+  expect(changeMessages(res, 's1', 'EXTERNAL_ON_TYPE_EXTENSION_REMOVAL')).toStrictEqual([
+    'Removed @external from field "Product.upc" as it is a key of an extension type'
+  ]);
+
+  expect(changeMessages(res, 's1', 'TYPE_EXTENSION_REMOVAL')).toStrictEqual([
+    'Switched type "Product" from an extension to a definition'
+  ]);
+
+  expect(changeMessages(res, 's1', 'UNUSED_EXTERNAL_REMOVAL')).toStrictEqual([
+    'Removed @external field "Product.name" as it was not used in any @key, @provides or @requires'
+  ]);
+
+  expect(changeMessages(res, 's1', 'EXTERNAL_ON_INTERFACE_REMOVAL')).toStrictEqual([
+    'Removed @external directive on interface type field "I.description": @external is nonsensical on interface fields'
+  ]);
+
+  expect(changeMessages(res, 's1', 'INACTIVE_PROVIDES_OR_REQUIRES_REMOVAL')).toStrictEqual([
+    'Removed directive @requires(fields: "upc") on "Product.inventory": none of the fields were truly @external'
+  ]);
+
+  expect(changeMessages(res, 's1', 'INACTIVE_PROVIDES_OR_REQUIRES_FIELDS_REMOVAL')).toStrictEqual([
+    'Updated directive @provides(fields: "upc description") on "Query.products" to @provides(fields: "description"): removed fields that were not truly @external'
+  ]);
+
+  expect(changeMessages(res, 's1', 'KEY_ON_INTERFACE_REMOVAL')).toStrictEqual([
+    'Removed @key on interface "I": while allowed by federation 0.x, @key on interfaces were completely ignored/had no effect'
+  ]);
+
+  expect(changeMessages(res, 's1', 'PROVIDES_ON_NON_COMPOSITE_REMOVAL')).toStrictEqual([
+    'Removed @provides directive on field "Random.x" as it is of non-composite type "Int": while not rejected by federation 0.x, such @provide is nonsensical and was ignored'
+  ]);
+
+  expect(res.subgraphs?.get('s1')?.toString()).toMatchString(`
+    schema
+      @link(url: "https://specs.apollo.dev/link/v1.0")
+      @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@requires", "@provides", "@external", "@shareable", "@tag", "@extends"])
+    {
+      query: Query
+    }
+
+    type Query {
+      products: [Product!]! @provides(fields: "description")
+    }
+
+    interface I {
+      upc: ID!
+      description: String
+    }
+
+    type Product implements I
+      @key(fields: "upc")
+    {
+      upc: ID!
+      inventory: Int
+      description: String @external
+    }
+
+    type Random {
+      x: Int
+    }
+
+    extend type Random {
+      y: Int
+    }
+  `);
+});
+
+test('update federation directive non-string arguments', () => {
+  const s = `
+    type Query {
+      a: A
+    }
+
+    type A @key(fields: id) @key(fields: ["id", "x"]) {
+      id: String
+      x: Int
+    }
+  `;
+
+  const subgraphs = new Subgraphs();
+  subgraphs.add(buildSubgraph('s', 'http://s', s));
+  const res = upgradeSubgraphsIfNecessary(subgraphs);
+  expect(res.errors).toBeUndefined();
+
+  expect(changeMessages(res, 's', 'FIELDS_ARGUMENT_COERCION_TO_STRING')).toStrictEqual([
+    'Coerced "fields" argument for directive @key for "A" into a string: coerced from @key(fields: id) to @key(fields: "id")',
+    'Coerced "fields" argument for directive @key for "A" into a string: coerced from @key(fields: ["id", "x"]) to @key(fields: "id x")',
+  ]);
+
+  expect(res.subgraphs?.get('s')?.toString()).toMatchString(`
+    schema
+      @link(url: "https://specs.apollo.dev/link/v1.0")
+      @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@requires", "@provides", "@external", "@shareable", "@tag", "@extends"])
+    {
+      query: Query
+    }
+
+    type Query {
+      a: A
+    }
+
+    type A
+      @key(fields: "id")
+      @key(fields: "id x")
+    {
+      id: String
+      x: Int
+    }
+  `);
+})

package/src/__tests__/subgraphValidation.test.ts

@@ -1,14 +1,15 @@
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
-import { errorCauses } from '..';
-import { buildSubgraph } from "../federation"
+import { errorCauses } from '../definitions';
+import { asFed2SubgraphDocument, 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);
+    const doc = asFed2SubgraphDocument(subgraphDefs);
+    buildSubgraph(subgraphName, `http://${subgraphName}`, doc).validate();
     return undefined;
   } catch (e) {
     const causes = errorCauses(e);
@@ -144,6 +145,7 @@ describe('fieldset-based directives', () => {
     `
     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' ],
+      ['EXTERNAL_ON_INTERFACE', '[S] Interface type field "T.f" is marked @external but @external is not allowed on interface fields (it is nonsensical).' ],
     ]);
   });
 
@@ -335,22 +337,6 @@ describe('fieldset-based directives', () => {
     `
     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'],
     ]);
   });
 

package/src/__tests__/values.test.ts

@@ -1,19 +1,17 @@
 import {
   Schema,
-  BuiltIns
 } from '../../dist/definitions';
 import { buildSchema } from '../../dist/buildSchema';
 import { parseOperation } from '../../dist/operations';
 
-function parseSchema(schema: string, builtIns?: BuiltIns): Schema {
+function parseSchema(schema: string): Schema {
   try {
-    return buildSchema(schema, builtIns);
+    return buildSchema(schema);
   } catch (e) {
     throw new Error('Error parsing the schema:\n' + e.toString());
   }
 }
 
-
 test('handles non-list value for list argument (as singleton)', () => {
   const schema = parseSchema(`
     enum Day {

package/src/buildSchema.ts

@@ -11,7 +11,6 @@ import {
   SchemaDefinitionNode,
   Source,
   TypeNode,
-  valueFromASTUntyped,
   ValueNode,
   NamedTypeNode,
   ArgumentNode,
@@ -22,10 +21,10 @@ import {
   Kind,
 } from "graphql";
 import { Maybe } from "graphql/jsutils/Maybe";
+import { valueFromASTUntyped } from "./values";
 import {
-  BuiltIns,
+  SchemaBlueprint,
   Schema,
-  graphQLBuiltIns,
   newNamedType,
   NamedTypeKind,
   NamedType,
@@ -51,57 +50,56 @@ import {
 } from "./definitions";
 
 function buildValue(value?: ValueNode): any {
-  // TODO: Should we rewrite a version of valueFromAST instead of using valueFromASTUntyped? Afaict, what we're missing out on is
-  // 1) coercions, which concretely, means:
-  //   - for enums, we get strings
-  //   - for int, we don't get the validation that it should be a 32bit value.
-  //   - 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.
   return value ? valueFromASTUntyped(value) : undefined;
 }
 
-export function buildSchema(source: string | Source, builtIns: BuiltIns = graphQLBuiltIns, validate: boolean = true): Schema {
-  return buildSchemaFromAST(parse(source), builtIns, validate);
+export type BuildSchemaOptions = {
+  blueprint?: SchemaBlueprint,
+  validate?: boolean,
 }
 
-export function buildSchemaFromAST(documentNode: DocumentNode, builtIns: BuiltIns = graphQLBuiltIns, validate: boolean = true): Schema {
-  const schema = new Schema(builtIns);
+export function buildSchema(source: string | Source, options?: BuildSchemaOptions): Schema {
+  return buildSchemaFromAST(parse(source), options);
+}
+
+export function buildSchemaFromAST(
+  documentNode: DocumentNode,
+  options?: BuildSchemaOptions,
+): Schema {
+  const schema = new Schema(options?.blueprint);
   // We do a first pass to add all empty types and directives definition. This ensure any reference on one of
   // those can be resolved in the 2nd pass, regardless of the order of the definitions in the AST.
-  const directiveDefinitionNodes = buildNamedTypeAndDirectivesShallow(documentNode, schema);
+  const { directiveDefinitions, schemaDefinitions, schemaExtensions } = buildNamedTypeAndDirectivesShallow(documentNode, schema);
 
   // We then deal with directive definition first. This is mainly for the sake of core schemas: the core schema
   // handling in `Schema` detects that the schema is a core one when it see the application of `@core(feature: ".../core/...")`
   // to the schema element. But that detection necessitates that the corresponding directive definition has been fully
   // populated (and at this point, we don't really know the name of the `@core` directive since it can be renamed, so
   // we just handle all directives).
-  for (const directiveDefinitionNode of directiveDefinitionNodes) {
+  for (const directiveDefinitionNode of directiveDefinitions) {
     buildDirectiveDefinitionInner(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!);
   }
+  for (const schemaDefinition of schemaDefinitions) {
+    buildSchemaDefinitionInner(schemaDefinition, schema.schemaDefinition);
+  }
+  for (const schemaExtension of schemaExtensions) {
+    buildSchemaDefinitionInner(schemaExtension, schema.schemaDefinition, schema.schemaDefinition.newExtension());
+  }
+
+  schema.blueprint.onDirectiveDefinitionAndSchemaParsed(schema);
 
   for (const definitionNode of documentNode.definitions) {
     switch (definitionNode.kind) {
       case 'OperationDefinition':
       case 'FragmentDefinition':
         throw new GraphQLError("Invalid executable definition found while building schema", definitionNode);
-      case 'SchemaDefinition':
-        buildSchemaDefinitionInner(definitionNode, schema.schemaDefinition);
-        break;
-      case 'SchemaExtension':
-        buildSchemaDefinitionInner(
-          definitionNode,
-          schema.schemaDefinition,
-          schema.schemaDefinition.newExtension());
-        break;
       case 'ScalarTypeDefinition':
       case 'ObjectTypeDefinition':
       case 'InterfaceTypeDefinition':
       case 'UnionTypeDefinition':
       case 'EnumTypeDefinition':
       case 'InputObjectTypeDefinition':
-        buildNamedTypeInner(definitionNode, schema.type(definitionNode.name.value)!);
+        buildNamedTypeInner(definitionNode, schema.type(definitionNode.name.value)!, schema.blueprint);
         break;
       case 'ScalarTypeExtension':
       case 'ObjectTypeExtension':
@@ -112,23 +110,34 @@ export function buildSchemaFromAST(documentNode: DocumentNode, builtIns: BuiltIn
         const toExtend = schema.type(definitionNode.name.value)!;
         const extension = toExtend.newExtension();
         extension.sourceAST = definitionNode;
-        buildNamedTypeInner(definitionNode, toExtend, extension);
+        buildNamedTypeInner(definitionNode, toExtend, schema.blueprint, extension);
         break;
     }
   }
 
-  Schema.prototype['forceSetCachedDocument'].call(schema, documentNode);
-  if (validate) {
+  if (options?.validate ?? true) {
     schema.validate();
   }
 
   return schema;
 }
 
-function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema: Schema): DirectiveDefinitionNode[] {
-  const directiveDefinitionNodes = [];
+function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema: Schema): {
+  directiveDefinitions: DirectiveDefinitionNode[],
+  schemaDefinitions: SchemaDefinitionNode[],
+  schemaExtensions: SchemaExtensionNode[],
+}  {
+  const directiveDefinitions = [];
+  const schemaDefinitions = [];
+  const schemaExtensions = [];
   for (const definitionNode of documentNode.definitions) {
     switch (definitionNode.kind) {
+      case 'SchemaDefinition':
+        schemaDefinitions.push(definitionNode);
+        break;
+      case 'SchemaExtension':
+        schemaExtensions.push(definitionNode);
+        break;
       case 'ScalarTypeDefinition':
       case 'ObjectTypeDefinition':
       case 'InterfaceTypeDefinition':
@@ -149,12 +158,16 @@ function buildNamedTypeAndDirectivesShallow(documentNode: DocumentNode, schema:
         }
         break;
       case 'DirectiveDefinition':
-        directiveDefinitionNodes.push(definitionNode);
+        directiveDefinitions.push(definitionNode);
         schema.addDirectiveDefinition(definitionNode.name.value);
         break;
     }
   }
-  return directiveDefinitionNodes;
+  return {
+    directiveDefinitions,
+    schemaDefinitions,
+    schemaExtensions,
+  }
 }
 
 type NodeWithDirectives = {directives?: ReadonlyArray<DirectiveNode>};
@@ -206,7 +219,9 @@ function buildSchemaDefinitionInner(
       opTypeNode);
   }
   schemaDefinition.sourceAST = schemaNode;
-  schemaDefinition.description = 'description' in schemaNode ? schemaNode.description?.value : undefined;
+  if ('description' in schemaNode) {
+    schemaDefinition.description = schemaNode.description?.value;
+  }
   buildAppliedDirectives(schemaNode, schemaDefinition, extension);
 }
 
@@ -235,7 +250,8 @@ function buildArgs(argumentsNode: NodeWithArguments): Record<string, any> {
 function buildNamedTypeInner(
   definitionNode: DefinitionNode & NodeWithDirectives & NodeWithDescription,
   type: NamedType,
-  extension?: Extension<any>
+  blueprint: SchemaBlueprint,
+  extension?: Extension<any>,
 ) {
   switch (definitionNode.kind) {
     case 'ObjectTypeDefinition':
@@ -244,6 +260,9 @@ function buildNamedTypeInner(
     case 'InterfaceTypeExtension':
       const fieldBasedType = type as ObjectType | InterfaceType;
       for (const fieldNode of definitionNode.fields ?? []) {
+        if (blueprint.ignoreParsedField(type, fieldNode.name.value)) {
+          continue;
+        }
         const field = fieldBasedType.addField(fieldNode.name.value);
         field.setOfExtension(extension);
         buildFieldDefinitionInner(fieldNode, field);