@apollo/federation-internals 2.7.0 → 2.7.2

package/src/federation.ts

@@ -79,6 +79,7 @@ import {
   FederationTypeName,
   FEDERATION1_TYPES,
   FEDERATION1_DIRECTIVES,
+  FederationSpecDefinition,
 } from "./specs/federationSpec";
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
@@ -93,10 +94,18 @@ import {
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
-const federationSpec = FEDERATION_VERSIONS.latest();
+const federationSpec = (version?: FeatureVersion): FederationSpecDefinition => {
+  if (!version) return FEDERATION_VERSIONS.latest();
+  const spec = FEDERATION_VERSIONS.find(version);
+  assert(spec, `Federation spec version ${version} is not known`);
+  return spec;
+};
+
 // Some users rely on auto-expanding fed v1 graphs with fed v2 directives. While technically we should only expand @tag
 // directive from v2 definitions, we will continue expanding other directives (up to v2.4) to ensure backwards compatibility.
-const autoExpandedFederationSpec = FEDERATION_VERSIONS.find(new FeatureVersion(2, 4))!;
+const autoExpandedFederationSpec = federationSpec(new FeatureVersion(2, 4));
+
+const latestFederationSpec = federationSpec();
 
 // We don't let user use this as a subgraph name. That allows us to use it in `query graphs` to name the source of roots
 // in the "federated query graph" without worrying about conflict (see `FEDERATED_GRAPH_ROOT_SOURCE` in `querygraph.ts`).
@@ -601,7 +610,7 @@ export class FederationMetadata {
   }
 
   federationFeature(): CoreFeature | undefined {
-    return this.schema.coreFeatures?.getByIdentity(federationSpec.identity);
+    return this.schema.coreFeatures?.getByIdentity(latestFederationSpec.identity);
   }
 
   private externalTester(): ExternalTester {
@@ -663,7 +672,7 @@ export class FederationMetadata {
     if (this.isFed2Schema()) {
       const coreFeatures = this.schema.coreFeatures;
       assert(coreFeatures, 'Schema should be a core schema');
-      const federationFeature = coreFeatures.getByIdentity(federationSpec.identity);
+      const federationFeature = coreFeatures.getByIdentity(latestFederationSpec.identity);
       assert(federationFeature, 'Schema should have the federation feature');
       return federationFeature.directiveNameInSchema(name);
     } else {
@@ -685,7 +694,7 @@ export class FederationMetadata {
     if (this.isFed2Schema()) {
       const coreFeatures = this.schema.coreFeatures;
       assert(coreFeatures, 'Schema should be a core schema');
-      const federationFeature = coreFeatures.getByIdentity(federationSpec.identity);
+      const federationFeature = coreFeatures.getByIdentity(latestFederationSpec.identity);
       assert(federationFeature, 'Schema should have the federation feature');
       return federationFeature.typeNameInSchema(name);
     } else {
@@ -1190,7 +1199,7 @@ function findUnusedNamedForLinkDirective(schema: Schema): string | undefined {
   }
 }
 
-export function setSchemaAsFed2Subgraph(schema: Schema) {
+export function setSchemaAsFed2Subgraph(schema: Schema, useLatest: boolean = false) {
   let core = schema.coreFeatures;
   let spec: CoreSpecDefinition;
   if (core) {
@@ -1209,11 +1218,16 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
     assert(core, 'Schema should now be a core schema');
   }
 
-  assert(!core.getByIdentity(federationSpec.identity), 'Schema already set as a federation subgraph');
+  const fedSpec = useLatest ? latestFederationSpec : autoExpandedFederationSpec;
+
+  assert(!core.getByIdentity(fedSpec.identity), 'Schema already set as a federation subgraph');
   schema.schemaDefinition.applyDirective(
     core.coreItself.nameInSchema,
     {
-      url: federationSpec.url.toString(),
+      // note that there is a mismatch between url and directives that are imported. This is because
+      // we want to maintain backward compatibility for those who have already upgraded and we had been upgrading the url to
+      // latest, but we never automatically import directives that exist past 2.4
+      url: fedSpec.url.toString(),
       import: autoExpandedFederationSpec.directiveSpecs().map((spec) => `@${spec.name}`),
     }
   );
@@ -1226,21 +1240,25 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
 // 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.7", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective", "@interfaceObject", "@authenticated", "@requiresScopes", "@policy", "@sourceAPI", "@sourceType", "@sourceField"])';
-// This is the full @link declaration that is added when upgrading fed v1 subgraphs to v2 version. It should only be used by tests.
+
+// This is the federation @link for tests that go through the asFed2SubgraphDocument function.
 export const FEDERATION2_LINK_WITH_AUTO_EXPANDED_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.7", 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"])';
+
 /**
  * Given a document that is assumed to _not_ be a fed2 schema (it does not have a `@link` to the federation spec),
  * returns an equivalent document that `@link` to the last known federation spec.
  *
  * @param document - the document to "augment".
- * @param options.addAsSchemaExtension - defines whethere the added `@link` is added as a schema extension (`extend schema`) or
+ * @param options.addAsSchemaExtension - defines whether the added `@link` is added as a schema extension (`extend schema`) or
  *   added to the schema definition. Defaults to `true` (added as an extension), as this mimics what we tends to write manually.
  * @param options.includeAllImports - defines whether we should auto import ALL latest federation v2 directive definitions or include
  *   only limited set of directives (i.e. federation v2.4 definitions)
  */
 export function asFed2SubgraphDocument(document: DocumentNode, options?: { addAsSchemaExtension?: boolean, includeAllImports?: boolean }): DocumentNode {
-  const importedDirectives = options?.includeAllImports ? federationSpec.directiveSpecs() : autoExpandedFederationSpec.directiveSpecs();
+  const importedDirectives = options?.includeAllImports ? latestFederationSpec.directiveSpecs() : autoExpandedFederationSpec.directiveSpecs();
   const directiveToAdd: ConstDirectiveNode = ({
     kind: Kind.DIRECTIVE,
     name: { kind: Kind.NAME, value: linkDirectiveDefaultName },
@@ -1248,7 +1266,7 @@ export function asFed2SubgraphDocument(document: DocumentNode, options?: { addAs
       {
         kind: Kind.ARGUMENT,
         name: { kind: Kind.NAME, value: 'url' },
-        value: { kind: Kind.STRING, value: federationSpec.url.toString() }
+        value: { kind: Kind.STRING, value: latestFederationSpec.url.toString() }
       },
       {
         kind: Kind.ARGUMENT,
@@ -1374,7 +1392,7 @@ export function buildSubgraph(
 
 export function newEmptyFederation2Schema(config?: SchemaConfig): Schema {
   const schema = new Schema(new FederationBlueprint(true), config);
-  setSchemaAsFed2Subgraph(schema);
+  setSchemaAsFed2Subgraph(schema, true);
   return schema;
 }
 

package/src/operations.ts

@@ -973,6 +973,18 @@ export class Operation {
     return this.withUpdatedSelectionSetAndFragments(optimizedSelection, finalFragments ?? undefined);
   }
 
+  generateQueryFragments(): Operation {
+    const [minimizedSelectionSet, fragments] = this.selectionSet.minimizeSelectionSet();
+    return new Operation(
+      this.schema,
+      this.rootKind,
+      minimizedSelectionSet,
+      this.variableDefinitions,
+      fragments,
+      this.name,
+    );
+  }
+
   expandAllFragments(): Operation {
     // We clear up the fragments since we've expanded all.
     // Also note that expanding fragment usually generate unecessary fragments/inefficient selections, so it
@@ -1378,28 +1390,6 @@ export class NamedFragments {
     });
   }
 
-  // When we rebase named fragments on a subgraph schema, only a subset of what the fragment handles may belong
-  // to that particular subgraph. And there are a few sub-cases where that subset is such that we basically need or
-  // want to consider to ignore the fragment for that subgraph, and that is when:
-  // 1. the subset that apply is actually empty. The fragment wouldn't be valid in this case anyway.
-  // 2. the subset is a single leaf field: in that case, using the one field directly is just shorter than using
-  //   the fragment, so we consider the fragment don't really apply to that subgraph. Technically, using the
-  //   fragment could still be of value if the fragment name is a lot smaller than the one field name, but it's
-  //   enough of a niche case that we ignore it. Note in particular that one sub-case of this rule that is likely
-  //   to be common is when the subset ends up being just `__typename`: this would basically mean the fragment
-  //   don't really apply to the subgraph, and that this will ensure this is the case.
-  private selectionSetIsWorthUsing(selectionSet: SelectionSet): boolean {
-    const selections = selectionSet.selections();
-    if (selections.length === 0) {
-      return false;
-    }
-    if (selections.length === 1) {
-      const s = selections[0];
-      return !(s.kind === 'FieldSelection' && s.element.isLeafField());
-    }
-    return true;
-  }
-
   rebaseOn(schema: Schema): NamedFragments | undefined {
     return this.mapInDependencyOrder((fragment, newFragments) => {
       const rebasedType = schema.type(fragment.selectionSet.parentType.name);
@@ -1411,7 +1401,7 @@ export class NamedFragments {
       // Rebasing can leave some inefficiencies in some case (particularly when a spread has to be "expanded", see `FragmentSpreadSelection.rebaseOn`),
       // so we do a top-level normalization to keep things clean.
       rebasedSelection = rebasedSelection.normalize({ parentType: rebasedType });
-      return this.selectionSetIsWorthUsing(rebasedSelection)
+      return rebasedSelection.isWorthUsing()
         ? new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection)
         : undefined;
     });
@@ -1535,6 +1525,60 @@ export class SelectionSet {
     this._selections = mapValues(keyedSelections);
   }
 
+  /**
+   * Takes a selection set and extracts inline fragments into named fragments,
+   * reusing generated named fragments when possible.
+   */
+  minimizeSelectionSet(
+    namedFragments: NamedFragments = new NamedFragments(),
+    seenSelections: Map<string, [SelectionSet, NamedFragmentDefinition][]> = new Map(),
+  ): [SelectionSet, NamedFragments] {
+    const minimizedSelectionSet = this.lazyMap((selection) => {
+      if (selection.kind === 'FragmentSelection' && selection.element.typeCondition && selection.element.appliedDirectives.length === 0
+          && selection.selectionSet && selection.selectionSet.isWorthUsing() ) {
+        // No proper hash code, so we use a unique enough number that's cheap to
+        // compute and handle collisions as necessary.
+        const mockHashCode = `on${selection.element.typeCondition}` + selection.selectionSet.selections().length;
+        const equivalentSelectionSetCandidates = seenSelections.get(mockHashCode);
+        if (equivalentSelectionSetCandidates) {
+          // See if any candidates have an equivalent selection set, i.e. {x y} and {y x}.
+          const match = equivalentSelectionSetCandidates.find(([candidateSet]) => candidateSet.equals(selection.selectionSet!));
+          if (match) {
+            // If we found a match, we can reuse the fragment (but we still need
+            // to create a new FragmentSpread since parent types may differ).
+            return new FragmentSpreadSelection(this.parentType, namedFragments, match[1], []);
+          }
+        }
+
+        // No match, so we need to create a new fragment. First, we minimize the
+        // selection set before creating the fragment with it.
+        const [minimizedSelectionSet] = selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections);
+        const fragmentDefinition = new NamedFragmentDefinition(
+          this.parentType.schema(),
+          `_generated_${mockHashCode}_${equivalentSelectionSetCandidates?.length ?? 0}`,
+          selection.element.typeCondition
+        ).setSelectionSet(minimizedSelectionSet);
+
+        // Create a new "hash code" bucket or add to the existing one.
+        if (!equivalentSelectionSetCandidates) {
+          seenSelections.set(mockHashCode, [[selection.selectionSet, fragmentDefinition]]);
+          namedFragments.add(fragmentDefinition);
+        } else {
+          equivalentSelectionSetCandidates.push([selection.selectionSet, fragmentDefinition]);
+        }
+
+        return new FragmentSpreadSelection(this.parentType, namedFragments, fragmentDefinition, []);
+      } else if (selection.kind === 'FieldSelection') {
+        if (selection.selectionSet) {
+          selection = selection.withUpdatedSelectionSet(selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections)[0]);
+        }
+      }
+      return selection;
+    });
+
+    return [minimizedSelectionSet, namedFragments];
+  }
+
   selectionsInReverseOrder(): readonly Selection[] {
     const length = this._selections.length;
     const reversed = new Array<Selection>(length);
@@ -2077,6 +2121,34 @@ export class SelectionSet {
         : selectionsToString;
     }
   }
+
+  // `isWorthUsing` method is used to determine whether we want to factor out
+  // given selection set into a named fragment so it can be reused across the query.
+  // Currently, it is used in these cases:
+  // 1) to reuse existing named fragments in subgraph queries (when reuseQueryFragments is on)
+  // 2) to factor selection sets into named fragments (when generateQueryFragments is on).
+  //
+  // When we rebase named fragments on a subgraph schema, only a subset of what the fragment handles may belong
+  // to that particular subgraph. And there are a few sub-cases where that subset is such that we basically need or
+  // want to consider to ignore the fragment for that subgraph, and that is when:
+  // 1. the subset that apply is actually empty. The fragment wouldn't be valid in this case anyway.
+  // 2. the subset is a single leaf field: in that case, using the one field directly is just shorter than using
+  //   the fragment, so we consider the fragment don't really apply to that subgraph. Technically, using the
+  //   fragment could still be of value if the fragment name is a lot smaller than the one field name, but it's
+  //   enough of a niche case that we ignore it. Note in particular that one sub-case of this rule that is likely
+  //   to be common is when the subset ends up being just `__typename`: this would basically mean the fragment
+  //   don't really apply to the subgraph, and that this will ensure this is the case.
+  isWorthUsing(): boolean {
+    const selections = this.selections();
+    if (selections.length === 0) {
+      return false;
+    }
+    if (selections.length === 1) {
+      const s = selections[0];
+      return !(s.kind === 'FieldSelection' && s.element.isLeafField());
+    }
+    return true;
+  }
 }
 
 type PathBasedUpdate = { path: OperationPath, selections?: Selection | SelectionSet | readonly Selection[] };

package/src/specs/coreSpec.ts

@@ -640,6 +640,28 @@ export class FeatureVersion {
     return new this(+match[1], +match[2])
   }
 
+  /**
+   * Find the maximum version in a collection of versions, returning undefined in the case
+   * that the collection is empty.
+   *
+   * # Example
+   * ```
+   * expect(FeatureVersion.max([new FeatureVersion(1, 0), new FeatureVersion(2, 0)])).toBe(new FeatureVersion(2, 0))
+   * expect(FeatureVersion.max([])).toBe(undefined)
+   * ```
+   */
+  public static max(versions: Iterable<FeatureVersion>): FeatureVersion | undefined {
+    let max: FeatureVersion | undefined;
+
+    for (const version of versions) {
+      if (!max || version > max) {
+        max = version;
+      }
+    }
+
+    return max;
+  }
+
   /**
    * Return true if and only if this FeatureVersion satisfies the `required` version
    *