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

package/src/error.ts

@@ -56,6 +56,62 @@ export function extractGraphQLErrorOptions(e: GraphQLError): GraphQLErrorOptions
   };
 }
 
+class AggregateGraphQLError extends GraphQLError {
+  constructor(
+    code: String,
+    message: string,
+    readonly causes: GraphQLError[],
+    options?: GraphQLErrorOptions,
+  ) {
+    super(
+      message + '. Caused by:\n' + causes.map((c) => c.toString()).join('\n\n'),
+      {
+        ...options,
+        extensions: { code },
+      }
+    );
+  }
+
+  toString() {
+    let output = `[${this.extensions.code}] ${super.toString()}`
+    output += "\ncaused by:";
+    for (const cause of this.causes) {
+      output += "\n\n  - ";
+      output += cause.toString().split("\n").join("\n    ");
+    }
+    return output;
+  }
+}
+
+export function aggregateError(code: String, message: string, causes: GraphQLError[]): GraphQLError {
+  return new AggregateGraphQLError(code, message, causes);
+}
+
+/**
+ * Given an error, check if it is a graphQL error and potentially extract its causes if is aggregate.
+ * If the error is not a graphQL error, undefined is returned.
+ */
+export function errorCauses(e: Error): GraphQLError[] | undefined {
+  if (e instanceof AggregateGraphQLError) {
+    return e.causes;
+  }
+  if (e instanceof GraphQLError) {
+    return [e];
+  }
+  return undefined;
+}
+
+export function printGraphQLErrorsOrRethrow(e: Error): string {
+  const causes = errorCauses(e);
+  if (!causes) {
+    throw e;
+  }
+  return causes.map(e => e.toString()).join('\n\n');
+}
+
+export function printErrors(errors: GraphQLError[]): string {
+  return errors.map(e => e.toString()).join('\n\n');
+}
 /*
  * Most codes currently originate from the initial fed 2 release so we use this for convenience.
  * This can be changed later, inline versions everywhere, if that becomes irrelevant.
@@ -144,6 +200,11 @@ const TYPE_DEFINITION_INVALID = makeCodeDefinition(
   'A built-in or federation type has an invalid definition in the schema.',
 );
 
+const UNSUPPORTED_LINKED_FEATURE = makeCodeDefinition(
+  'UNSUPPORTED_LINKED_FEATURE',
+  'Indicates that a feature used in a @link is either unsupported or is used with unsupported options.',
+);
+
 const UNKNOWN_FEDERATION_LINK_VERSION = makeCodeDefinition(
   'UNKNOWN_FEDERATION_LINK_VERSION',
   'The version of federation in a @link directive on the schema is unknown.',
@@ -479,6 +540,7 @@ export const ERRORS = {
   INVALID_GRAPHQL,
   DIRECTIVE_DEFINITION_INVALID,
   TYPE_DEFINITION_INVALID,
+  UNSUPPORTED_LINKED_FEATURE,
   UNKNOWN_FEDERATION_LINK_VERSION,
   UNKNOWN_LINK_VERSION,
   KEY_FIELDS_HAS_ARGS,

package/src/extractSubgraphsFromSupergraph.ts

@@ -1,11 +1,13 @@
 import {
   baseType,
   CompositeType,
+  copyDirectiveDefinitionToSchema,
   Directive,
   FieldDefinition,
   InputFieldDefinition,
   InputObjectType,
   InterfaceType,
+  isExecutableDirectiveLocation,
   isEnumType,
   isInterfaceType,
   isObjectType,
@@ -32,6 +34,7 @@ import { validateSupergraph } from "./supergraphs";
 import { builtTypeReference } from "./buildSchema";
 import { isSubtype } from "./types";
 import { printSchema } from "./print";
+import { parseSelectionSet } from "./operations";
 import fs from 'fs';
 import path from 'path';
 import { validateStringContainsBoolean } from "./utils";
@@ -80,6 +83,114 @@ class SubgraphExtractionError {
   }
 }
 
+function collectFieldReachableTypesForSubgraph(
+  supergraph: Schema,
+  subgraphName: string,
+  addReachableType: (t: NamedType) => void,
+  fieldInfoInSubgraph: (f: FieldDefinition<any> | InputFieldDefinition, subgraphName: string) => { isInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+  typeInfoInSubgraph: (t: NamedType, subgraphName: string) => { isEntityWithKeyInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+): void {
+  const seenTypes = new Set<string>();
+  // The types reachable at "top-level" are both the root types, plus any entity type with a key in this subgraph.
+  const stack = supergraph.schemaDefinition.roots().map((root) => root.type as NamedType)
+  for (const type of supergraph.types()) {
+    const { isEntityWithKeyInSubgraph, typesInFederationDirectives } = typeInfoInSubgraph(type, subgraphName);
+    if (isEntityWithKeyInSubgraph) {
+      stack.push(type);
+    }
+    typesInFederationDirectives.forEach((t) => stack.push(t));
+  }
+  while (stack.length > 0) {
+    const type = stack.pop()!;
+    addReachableType(type);
+    if (seenTypes.has(type.name)) {
+      continue;
+    }
+    seenTypes.add(type.name);
+    switch (type.kind) {
+      // @ts-expect-error: we fall-through to ObjectType for fields and implemented interfaces.
+      case 'InterfaceType':
+        // If an interface if reachable, then all of its implementation are too (a field returning the interface could return any of the
+        // implementation at runtime typically).
+        type.allImplementations().forEach((t) => stack.push(t));
+      case 'ObjectType':
+        type.interfaces().forEach((t) => stack.push(t));
+        for (const field of type.fields()) {
+          const { isInSubgraph, typesInFederationDirectives } = fieldInfoInSubgraph(field, subgraphName);
+          if (isInSubgraph) {
+            field.arguments().forEach((arg) => stack.push(baseType(arg.type!)));
+            stack.push(baseType(field.type!));
+            typesInFederationDirectives.forEach((t) => stack.push(t));
+          }
+        }
+        break;
+      case 'InputObjectType':
+        for (const field of type.fields()) {
+          const { isInSubgraph, typesInFederationDirectives } = fieldInfoInSubgraph(field, subgraphName);
+          if (isInSubgraph) {
+            stack.push(baseType(field.type!));
+            typesInFederationDirectives.forEach((t) => stack.push(t));
+          }
+        }
+        break;
+      case 'UnionType':
+        type.members().forEach((m) => stack.push(m.type));
+        break;
+    }
+  }
+
+  for (const directive of supergraph.directives()) {
+    // In fed1 supergraphs, which is the only place this is called, only executable directive from subgraph only ever made
+    // it to the supergraph. Skipping anything else saves us from worrying about supergraph-specific directives too.
+    if (!directive.hasExecutableLocations()) {
+      continue;
+    }
+    directive.arguments().forEach((arg) => stack.push(baseType(arg.type!)));
+  }
+}
+
+function collectFieldReachableTypesForAllSubgraphs(
+  supergraph: Schema,
+  allSubgraphs: readonly string[],
+  fieldInfoInSubgraph: (f: FieldDefinition<any> | InputFieldDefinition, subgraphName: string) => { isInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+  typeInfoInSubgraph: (t: NamedType, subgraphName: string) => { isEntityWithKeyInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+): Map<string, Set<string>> {
+  const reachableTypesBySubgraphs = new Map<string, Set<string>>();
+  for (const subgraphName of allSubgraphs) {
+    const reachableTypes = new Set<string>();
+    collectFieldReachableTypesForSubgraph(
+      supergraph,
+      subgraphName,
+      (t) => reachableTypes.add(t.name),
+      fieldInfoInSubgraph,
+      typeInfoInSubgraph,
+    );
+    reachableTypesBySubgraphs.set(subgraphName, reachableTypes);
+  }
+  return reachableTypesBySubgraphs;
+}
+
+function typesUsedInFederationDirective(fieldSet: string | undefined, parentType: CompositeType): NamedType[] {
+  if (!fieldSet) {
+    return [];
+  }
+
+  const usedTypes: NamedType[] = [];
+  parseSelectionSet({
+    parentType,
+    source: fieldSet,
+    fieldAccessor: (type, fieldName) => {
+      const field = type.field(fieldName);
+      if (field) {
+        usedTypes.push(baseType(field.type!));
+      }
+      return field;
+    },
+    validate: false,
+  });
+  return usedTypes;
+}
+
 export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
   const [coreFeatures, joinSpec] = validateSupergraph(supergraph);
   const isFed1 = joinSpec.version.equals(new FeatureVersion(0, 1));
@@ -88,6 +199,61 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     const [subgraphs, graphEnumNameToSubgraphName] = collectEmptySubgraphs(supergraph, joinSpec);
     const typeDirective = joinSpec.typeDirective(supergraph);
     const implementsDirective = joinSpec.implementsDirective(supergraph);
+    const ownerDirective = joinSpec.ownerDirective(supergraph);
+    const fieldDirective = joinSpec.fieldDirective(supergraph);
+
+    const getSubgraph = (application: Directive<any, { graph: string }>) => graphEnumNameToSubgraphName.get(application.arguments().graph);
+
+    /*
+     * Fed2 supergraph have "provenance" information for all types and fields, so we can faithfully extract subgraph relatively easily.
+     * For fed1 supergraph however, only entity types are marked with `@join__type` and `@join__field`. Which mean that for value types,
+     * we cannot directly know in which subgraphs they were initially defined. One strategy consists in "extracting" value types into
+     * all subgraphs blindly: functionally, having some unused types in an extracted subgraph schema does not matter much. However, adding
+     * those useless types increases memory usage, and we've seen some case with lots of subgraphs and lots of value types where those
+     * unused types balloon up memory usage (from 100MB to 1GB in one example; obviously, this is made worst by the fact that javascript
+     * is pretty memory heavy in the first place). So to avoid that problem, for fed1 supergraph, we do a first pass where we collect
+     * for all the subgraphs the set of types that are actually reachable in that subgraph. As we extract do the actual type extraction,
+     * we use this to ignore non-reachable types for any given subgraph.
+     */
+    let includeTypeInSubgraph: (t: NamedType, name: string) => boolean = () => true;
+    if (isFed1) {
+      const reachableTypesBySubgraph = collectFieldReachableTypesForAllSubgraphs(
+        supergraph,
+        subgraphs.names(),
+        (f, name) => {
+          const fieldApplications: Directive<any, { graph: string, requires?: string, provides?: string }>[] = f.appliedDirectivesOf(fieldDirective);
+          if (fieldApplications.length) {
+            const application = fieldApplications.find((application) => getSubgraph(application) === name);
+            if (application) {
+              const args = application.arguments();
+              const typesInFederationDirectives =
+                typesUsedInFederationDirective(args.provides, baseType(f.type!) as CompositeType)
+                .concat(typesUsedInFederationDirective(args.requires, f.parent));
+              return { isInSubgraph: true, typesInFederationDirectives };
+            } else {
+              return { isInSubgraph: false, typesInFederationDirectives: [] };
+            }
+          } else {
+            // No field application depends on the "owner" directive on the type. If we have no owner, then the
+            // field is in all subgraph and we return true. Otherwise, the field is only in the owner subgraph.
+            // In any case, the field cannot have a requires or provides
+            const ownerApplications = ownerDirective ? f.parent.appliedDirectivesOf(ownerDirective) : [];
+            return { isInSubgraph: !ownerApplications.length || getSubgraph(ownerApplications[0]) == name, typesInFederationDirectives: [] };
+          }
+        },
+        (t, name) => {
+          const typeApplications: Directive<any, { graph: string, key?: string}>[] = t.appliedDirectivesOf(typeDirective);
+          const application = typeApplications.find((application) => (application.arguments().key && (getSubgraph(application) === name)));
+          if (application) {
+            const typesInFederationDirectives = typesUsedInFederationDirective(application.arguments().key, t as CompositeType);
+            return { isEntityWithKeyInSubgraph: true, typesInFederationDirectives };
+          } else {
+            return { isEntityWithKeyInSubgraph: false, typesInFederationDirectives: [] };
+          }
+        },
+      );
+      includeTypeInSubgraph = (t, name) => reachableTypesBySubgraph.get(name)?.has(t.name) ?? false;
+    }
 
     // Next, we iterate on all types and add it to the proper subgraphs (along with any @key).
     // Note that we first add all types empty and populate the types next. This avoids having to care about the iteration
@@ -95,13 +261,15 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
       const typeApplications = type.appliedDirectivesOf(typeDirective);
       if (!typeApplications.length) {
-        // Imply the type is in all subgraphs (technically, some subgraphs may not have had this type, but adding it
-        // in that case is harmless because it will be unreachable anyway).
-        subgraphs.values().map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
+        // Imply we don't know in which subgraph the type is, so we had it in all subgraph in which the type is reachable.
+        subgraphs
+          .values()
+          .filter((sg) => includeTypeInSubgraph(type, sg.name))
+          .map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
       } else {
         for (const application of typeApplications) {
           const args = application.arguments();
-          const subgraphName = graphEnumNameToSubgraphName.get(args.graph)!;
+          const subgraphName = getSubgraph(application)!;
           const schema = subgraphs.get(subgraphName)!.schema;
           // We can have more than one type directive for a given subgraph
           let subgraphType = schema.type(type.name);
@@ -119,8 +287,6 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
       }
     }
 
-    const ownerDirective = joinSpec.ownerDirective(supergraph);
-    const fieldDirective = joinSpec.fieldDirective(supergraph);
     // We can now populate all those types (with relevant @provides and @requires on fields).
     for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
       switch (type.kind) {
@@ -179,7 +345,14 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
                 const args = application.arguments();
                 const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
                 const subgraphField = addSubgraphField(field, subgraph, args.type);
-                assert(subgraphField, () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
+                if (!subgraphField) {
+                  // It's unlikely but possible that a fed1 supergraph has a `@provides` on a field of a value type,
+                  // and that value type is actually unreachable. Because we trim unreachable types for fed1 supergraph
+                  // (see comment on `includeTypeInSubgraph` above), it would mean we get `undefined` here. It's fine
+                  // however: the type is unreachable in this subgraph, so ignoring that field application is fine too.
+                  assert(!includeTypeInSubgraph(type, subgraph.name), () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
+                  continue;
+                }
                 if (args.requires) {
                   subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': args.requires});
                 }
@@ -234,6 +407,7 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
       }
     }
 
+    const allExecutableDirectives = supergraph.directives().filter((def) => def.hasExecutableLocations());
     for (const subgraph of subgraphs) {
       if (isFed1) {
         // The join spec in fed1 was not including external fields. Let's make sure we had them or we'll get validation
@@ -266,6 +440,23 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
             break;
         }
       }
+
+      // Lastly, we add all the "executable" directives from the supergraph to each subgraphs, as those may be part
+      // of a query and end up in any subgraph fetches. We do this "last" to make sure that if one of the directive
+      // use a type for an argument, that argument exists.
+      // Note that we don't bother with non-executable directives at the moment since we've don't extract their
+      // applications. It might become something we need later, but we don't so far.
+      for (const definition of allExecutableDirectives) {
+        // Note that we skip any potentially applied directives in the argument of the copied definition, because as said
+        // in the comment above, we haven't copied type-system directives. And so far, we really don't care about those
+        // applications.
+        copyDirectiveDefinitionToSchema({
+          definition,
+          schema: subgraph.schema,
+          copyDirectiveApplicationsInArguments: false,
+          locationFilter: (loc) => isExecutableDirectiveLocation(loc),
+        });
+      }
     }
 
     // TODO: Not sure that code is needed anymore (any field necessary to validate an interface will have been marked

package/src/federation.ts

@@ -7,7 +7,6 @@ import {
   Directive,
   DirectiveDefinition,
   ErrGraphQLValidationFailed,
-  errorCauses,
   FieldDefinition,
   InputFieldDefinition,
   InterfaceType,
@@ -22,6 +21,7 @@ import {
   ScalarType,
   Schema,
   SchemaBlueprint,
+  SchemaConfig,
   SchemaDefinition,
   SchemaElement,
   sourceASTs,
@@ -54,6 +54,7 @@ import {
   ERRORS,
   withModifiedErrorMessage,
   extractGraphQLErrorOptions,
+  errorCauses,
 } from "./error";
 import { computeShareables } from "./precompute";
 import {
@@ -703,7 +704,9 @@ export class FederationBlueprint extends SchemaBlueprint {
   }
 
   onDirectiveDefinitionAndSchemaParsed(schema: Schema): GraphQLError[] {
-    return completeSubgraphSchema(schema);
+    const errors = completeSubgraphSchema(schema);
+    schema.schemaDefinition.processUnappliedDirectives();
+    return errors;
   }
 
   onInvalidation(schema: Schema) {
@@ -878,6 +881,10 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
     return error;
   }
+
+  applyDirectivesAfterParsing() {
+    return true;
+  }
 }
 
 function findUnusedNamedForLinkDirective(schema: Schema): string | undefined {
@@ -1018,8 +1025,8 @@ export function buildSubgraph(
   return subgraph.validate();
 }
 
-export function newEmptyFederation2Schema(): Schema {
-  const schema = new Schema(new FederationBlueprint(true));
+export function newEmptyFederation2Schema(config?: SchemaConfig): Schema {
+  const schema = new Schema(new FederationBlueprint(true), config);
   setSchemaAsFed2Subgraph(schema);
   return schema;
 }

package/src/inaccessibleSpec.ts

@@ -6,7 +6,6 @@ import {
   EnumType,
   EnumValue,
   ErrGraphQLAPISchemaValidationFailed,
-  executableDirectiveLocations,
   FieldDefinition,
   InputFieldDefinition,
   InputObjectType,
@@ -17,6 +16,7 @@ import {
   isListType,
   isNonNullType,
   isScalarType,
+  isTypeSystemDirectiveLocation,
   isVariable,
   NamedType,
   ObjectType,
@@ -682,11 +682,8 @@ function validateInaccessibleElements(
     }
   }
 
-  const executableDirectiveLocationSet = new Set(executableDirectiveLocations);
   for (const directive of schema.allDirectives()) {
-    const typeSystemLocations = directive.locations.filter((loc) =>
-      !executableDirectiveLocationSet.has(loc)
-    );
+    const typeSystemLocations = directive.locations.filter((loc) => isTypeSystemDirectiveLocation(loc));
     if (hasBuiltInName(directive)) {
       // Built-in directives (and their descendants) aren't allowed to be
       // @inaccessible, regardless of shadowing.