@apollo/federation-internals 2.13.3 → 2.14.0

package/src/federation.ts

@@ -1964,9 +1964,9 @@ export function setSchemaAsFed2Subgraph(schema: Schema, useLatest: boolean = fal
 
 // This is the full @link declaration as added by `asFed2SubgraphDocument`. It's here primarily for uses by tests that print and match
 // subgraph schema to avoid having to update 20+ tests every time we use a new directive or the order of import changes ...
-export const FEDERATION2_LINK_WITH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.13", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject", "@authenticated", "@requiresScopes", "@policy", "@context", "@fromContext", "@cost", "@listSize", "@cacheTag"])';
+export const FEDERATION2_LINK_WITH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.14", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject", "@authenticated", "@requiresScopes", "@policy", "@context", "@fromContext", "@cost", "@listSize", "@cacheTag"])';
 // This is the full @link declaration that is added when upgrading fed v1 subgraphs to v2 version. It should only be used by tests.
-export const FEDERATION2_LINK_WITH_AUTO_EXPANDED_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.13", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject"])';
+export const FEDERATION2_LINK_WITH_AUTO_EXPANDED_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.14", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject"])';
 
 // This is the federation @link for tests that go through the SchemaUpgrader.
 export const FEDERATION2_LINK_WITH_AUTO_EXPANDED_IMPORTS_UPGRADED = '@link(url: "https://specs.apollo.dev/federation/v2.4", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject"])';

package/src/schemaUpgrader.ts

@@ -32,7 +32,7 @@ import {
   Subgraph,
   Subgraphs,
 } from "./federation";
-import { assert, firstOf, MultiMap } from "./utils";
+import { assert, firstOf, MultiMap, SetMultiMap } from "./utils";
 import { valueEquals } from "./values";
 import { FEDERATION1_TYPES } from "./specs/federationSpec";
 
@@ -230,7 +230,8 @@ export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
 
   const subgraphs = new Subgraphs();
   let errors: GraphQLError[] = [];
-  const subgraphsUsingInterfaceObject = [];
+  const fed2InterfaceObjectTypesToSubgraphs = new SetMultiMap<string, string>();
+  const fed1InterfaceKeyTypesToSubgraphs = new SetMultiMap<string, string>();
   
   // build a data structure to help us do computation only once
   const objectTypeMap = new Map<string, Map<string, [ObjectType | InterfaceType, FederationMetadata]>>();
@@ -256,8 +257,9 @@ export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
   for (const subgraph of inputs.values()) {
     if (subgraph.isFed2Subgraph()) {
       subgraphs.add(subgraph);
-      if (subgraph.metadata().interfaceObjectDirective().applications().size > 0) {
-        subgraphsUsingInterfaceObject.push(subgraph.name);
+      for (const application of subgraph.metadata().interfaceObjectDirective().applications()) {
+        const typeName = (application.parent as NamedType).name;
+        fed2InterfaceObjectTypesToSubgraphs.add(typeName, subgraph.name);
       }
     } else {
       const res = new SchemaUpgrader(subgraph, inputs.values(), objectTypeMap).upgrade();
@@ -266,16 +268,19 @@ export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
       } else {
         subgraphs.add(res.upgraded);
         changes.set(subgraph.name, res.changes);
+        for (const typeName of res.interfaceKeyTypes) {
+          fed1InterfaceKeyTypesToSubgraphs.add(typeName, subgraph.name);
+        }
       }
     }
   }
-  if (errors.length === 0 && subgraphsUsingInterfaceObject.length > 0) {
-    const fed1Subgraphs = inputs.values().filter((s) => !s.isFed2Subgraph()).map((s) => s.name);
-    // Note that we exit this method early if everything is a fed2 schema, so we know at least one of them wasn't.
-    errors = [ ERRORS.INTERFACE_OBJECT_USAGE_ERROR.err(
-      'The @interfaceObject directive can only be used if all subgraphs have federation 2 subgraph schema (schema with a `@link` to "https://specs.apollo.dev/federation" version 2.0 or newer): '
-      + `@interfaceObject is used in ${printSubgraphNames(subgraphsUsingInterfaceObject)} but ${printSubgraphNames(fed1Subgraphs)} ${fed1Subgraphs.length > 1 ? 'are not' : 'is not a'} federation 2 subgraph schema.`,
-    )];
+  for (const [typeName, interfaceObjectSubgraphs] of fed2InterfaceObjectTypesToSubgraphs) {
+    const interfaceKeySubgraphs = fed1InterfaceKeyTypesToSubgraphs.get(typeName);
+    if (interfaceKeySubgraphs) {
+      errors.push(ERRORS.INTERFACE_OBJECT_USAGE_ERROR.err(
+        `The @interfaceObject directive is used on type "${typeName}" in ${printSubgraphNames([...interfaceObjectSubgraphs])}, which requires other subgraphs to resolve its type name via an interface @key. However, @key on an interface in a federation 1 subgraph does not mean it can fulfill the __typename-resolution requirement that @interfaceObject depends on. For ${printSubgraphNames([...interfaceKeySubgraphs])}, either upgrade them to federation 2 subgraphs or remove @key from the type.`,
+      ));
+    }
   }
 
   return errors.length === 0 ? { subgraphs, changes } : { errors };
@@ -324,6 +329,7 @@ class SchemaUpgrader {
   private readonly subgraph: Subgraph;
   private readonly metadata: FederationMetadata;
   private readonly errors: GraphQLError[] = [];
+  private readonly interfaceKeyTypes: Set<string> = new Set();
 
   constructor(private readonly originalSubgraph: Subgraph, private readonly allSubgraphs: readonly Subgraph[], private readonly objectTypeMap: Map<string, Map<string, [ObjectType | InterfaceType, FederationMetadata]>>) {
     // Note that as we clone the original schema, the 'sourceAST' values in the elements of the new schema will be those of the original schema
@@ -413,7 +419,14 @@ class SchemaUpgrader {
     }
   }
 
-  upgrade(): { upgraded: Subgraph, changes: UpgradeChanges, errors?: never } | { errors: GraphQLError[] } {
+  upgrade(): { upgraded: Subgraph, changes: UpgradeChanges, interfaceKeyTypes: Set<string>, errors?: never } | { errors: GraphQLError[] } {
+    // If there's already errors from constructor, we may not have inserted all
+    // directive definitions we need for upgrading (which may cause the methods
+    // below to throw). To avoid this, we return early in that case.
+    if (this.errors.length > 0) {
+      return { errors: this.errors };
+    }
+
     this.preUpgradeValidations();
 
     this.fixFederationDirectivesArguments();
@@ -452,6 +465,7 @@ class SchemaUpgrader {
       return {
         upgraded: this.subgraph,
         changes: this.changes,
+        interfaceKeyTypes: this.interfaceKeyTypes,
       };
     } catch (e) {
       const errors = errorCauses(e);
@@ -679,6 +693,7 @@ class SchemaUpgrader {
     for (const type of this.schema.interfaceTypes()) {
       for (const application of type.appliedDirectivesOf(this.metadata.keyDirective())) {
         this.addChange(new KeyOnInterfaceRemoval(type.name));
+        this.interfaceKeyTypes.add(type.name);
         application.remove();
       }
       for (const field of type.fields()) {

package/src/specs/connectSpec.ts

@@ -249,7 +249,7 @@ export class ConnectSpecDefinition extends FeatureDefinition {
       directive @connect(
         source: String
         id: String
-        http: ConnectHTTP!
+        http: ConnectHTTP
         batch: ConnectBatch
         errors: ConnectorErrors
         selection: JSONSelection!
@@ -277,7 +277,7 @@ export class ConnectSpecDefinition extends FeatureDefinition {
             type: (schema, feature) => {
               const connectHttpType =
                   lookupFeatureTypeInSchema<InputObjectType>(CONNECT_HTTP, 'InputObjectType', schema, feature);
-              return new NonNullType(connectHttpType);
+              return connectHttpType;
             }
           },
           {

package/src/specs/coreSpec.ts

@@ -209,6 +209,9 @@ export type CoreImport = {
   as?: string,
 };
 
+// The RegExp for a GraphQL name, plus an optional leading "@".
+const importRegExp = /^@?[_A-Za-z][_0-9A-Za-z]*$/;
+
 export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<SchemaDefinition, CoreOrLinkDirectiveArgs>): CoreImport[] {
   // Note: up to this point, we've kind of cheated with typing and force-casted the arguments to `CoreOrLinkDirectiveArgs`, and while this
   // graphQL type validations ensure this is "mostly" true, the `import' arg is an exception becuse it uses the `link__Import` scalar,
@@ -249,6 +252,13 @@ export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<
             ));
             continue importArgLoop;
           }
+          if (!importRegExp.test(value)) {
+            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+              `Invalid value for the "name" field for sub-value ${valueToString(elt)} of @link(import:) argument: must use a GraphQL name.`,
+              { nodes: directive.sourceAST },
+            ));
+            continue importArgLoop;
+          }
           name = value;
           break;
         case 'as':
@@ -259,6 +269,13 @@ export function extractCoreFeatureImports(url: FeatureUrl, directive: Directive<
             ));
             continue importArgLoop;
           }
+          if (!importRegExp.test(value)) {
+            errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(
+              `Invalid value for the "as" field for sub-value ${valueToString(elt)} of @link(import:) argument: must use a GraphQL name.`,
+              { nodes: directive.sourceAST },
+            ));
+            continue importArgLoop;
+          }
           break;
         default:
           errors.push(ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(

package/src/specs/federationSpec.ts

@@ -212,6 +212,7 @@ export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefiniti
   .add(new FederationSpecDefinition(new FeatureVersion(2, 10)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 11)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 12)))
-  .add(new FederationSpecDefinition(new FeatureVersion(2, 13)));
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 13)))
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 14)));
 
 registerKnownFeature(FEDERATION_VERSIONS);

package/src/utils.ts

@@ -375,15 +375,18 @@ export function printHumanReadableList(
 
   const { lastIdx } = names.reduce(
     ({ lastIdx, length }, name) => {
-      if (length + name.length > cutoff) {
+      const newLength = length + name.length;
+      if (newLength > cutoff) {
+        // there is no short-circuit logic in reduce
+        // if we already exceeded the cutoff length we need to pass the length that exceeded cutoff
         return {
           lastIdx,
-          length,
+          length: newLength,
         };
       }
       return {
         lastIdx: lastIdx + 1,
-        length: length + name.length,
+        length: newLength,
       };
     },
     { lastIdx: 0, length: 0}