@apollo/federation-internals 2.4.9 → 2.5.0

package/src/supergraphs.ts

@@ -3,10 +3,11 @@ import { ErrCoreCheckFailed, FeatureUrl, FeatureVersion } from "./coreSpec";
 import { CoreFeatures, Schema, sourceASTs } from "./definitions";
 import { joinIdentity, JoinSpecDefinition, JOIN_VERSIONS } from "./joinSpec";
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
-import { extractSubgraphsNamesAndUrlsFromSupergraph } from "./extractSubgraphsFromSupergraph";
+import { extractSubgraphsNamesAndUrlsFromSupergraph, extractSubgraphsFromSupergraph } from "./extractSubgraphsFromSupergraph";
 import { ERRORS } from "./error";
+import { Subgraphs } from ".";
 
-const SUPPORTED_FEATURES = new Set([
+export const DEFAULT_SUPPORTED_SUPERGRAPH_FEATURES = new Set([
   'https://specs.apollo.dev/core/v0.1',
   'https://specs.apollo.dev/core/v0.2',
   'https://specs.apollo.dev/join/v0.1',
@@ -21,24 +22,12 @@ const SUPPORTED_FEATURES = new Set([
 
 const coreVersionZeroDotOneUrl = FeatureUrl.parse('https://specs.apollo.dev/core/v0.1');
 
-export function buildSupergraphSchema(supergraphSdl: string | DocumentNode): [Schema, {name: string, url: string}[]] {
-  // We delay validation because `checkFeatureSupport` gives slightly more useful errors if, say, 'for' is used with core v0.1.
-  const schema = typeof supergraphSdl === 'string'
-    ? buildSchema(supergraphSdl, { validate: false })
-    : buildSchemaFromAST(supergraphSdl, { validate: false });
-
-  const [coreFeatures] = validateSupergraph(schema);
-  checkFeatureSupport(coreFeatures);
-  schema.validate();
-  return [schema, extractSubgraphsNamesAndUrlsFromSupergraph(schema)];
-}
-
 /**
  * Checks that only our hard-coded list of features are part of the provided schema, and that if
  * the schema uses core v0.1, then it doesn't use the 'for' (purpose) argument.
  * Throws if that is not true.
  */
-function checkFeatureSupport(coreFeatures: CoreFeatures) {
+function checkFeatureSupport(coreFeatures: CoreFeatures, supportedFeatures: Set<string>) {
   const errors: GraphQLError[] = [];
   const coreItself = coreFeatures.coreItself;
   if (coreItself.url.equals(coreVersionZeroDotOneUrl)) {
@@ -56,7 +45,7 @@ function checkFeatureSupport(coreFeatures: CoreFeatures) {
 
   for (const feature of coreFeatures.allFeatures()) {
     if (feature.url.equals(coreVersionZeroDotOneUrl) || feature.purpose === 'EXECUTION' || feature.purpose === 'SECURITY') {
-      if (!SUPPORTED_FEATURES.has(feature.url.base.toString())) {
+      if (!supportedFeatures.has(feature.url.base.toString())) {
         errors.push(ERRORS.UNSUPPORTED_LINKED_FEATURE.err(
           `feature ${feature.url} is for: ${feature.purpose} but is unsupported`,
           { nodes: feature.directive.sourceAST },
@@ -89,3 +78,62 @@ export function validateSupergraph(supergraph: Schema): [CoreFeatures, JoinSpecD
 export function isFed1Supergraph(supergraph: Schema): boolean {
   return validateSupergraph(supergraph)[1].version.equals(new FeatureVersion(0, 1));
 }
+
+export class Supergraph {
+  private readonly containedSubgraphs: readonly {name: string, url: string}[];
+  // Lazily computed as that requires a bit of work.
+  private _subgraphs?: Subgraphs;
+
+  constructor(
+    readonly schema: Schema,
+    supportedFeatures: Set<string> | null = DEFAULT_SUPPORTED_SUPERGRAPH_FEATURES,
+    private readonly shouldValidate: boolean = true,
+  ) {
+    const [coreFeatures] = validateSupergraph(schema);
+    
+    if (supportedFeatures !== null) {
+      checkFeatureSupport(coreFeatures, supportedFeatures);
+    }
+    
+    if (shouldValidate) {
+      schema.validate();
+    } else {
+      schema.assumeValid();
+    }
+
+    this.containedSubgraphs = extractSubgraphsNamesAndUrlsFromSupergraph(schema);
+  }
+
+  static build(supergraphSdl: string | DocumentNode, options?: { supportedFeatures?: Set<string>, validateSupergraph?: boolean }) {
+    // We delay validation because `checkFeatureSupport` in the constructor gives slightly more useful errors if, say, 'for' is used with core v0.1.
+    const schema = typeof supergraphSdl === 'string'
+      ? buildSchema(supergraphSdl, { validate: false })
+      : buildSchemaFromAST(supergraphSdl, { validate: false });
+
+    return new Supergraph(schema, options?.supportedFeatures, options?.validateSupergraph);
+  }
+
+  /**
+   * The list of names/urls of the subgraphs contained in this subgraph.
+   *
+   * Note that this is a subset of what `this.subgraphs()` returns, but contrarily to that method, this method does not do a full extraction of the
+   * subgraphs schema.
+   */
+  subgraphsMetadata(): readonly {name: string, url: string}[] {
+    return this.containedSubgraphs;
+  }
+
+  subgraphs(): Subgraphs {
+    if (!this._subgraphs) {
+      // Note that `extractSubgraphsFromSupergraph` redo a little bit of work we're already one, like validating
+      // the supergraph. We could refactor things to avoid it, but it's completely negligible in practice so we
+      // can leave that to "some day, maybe".
+      this._subgraphs = extractSubgraphsFromSupergraph(this.schema, this.shouldValidate);
+    }
+    return this._subgraphs;
+  }
+
+  apiSchema(): Schema {
+    return this.schema.toAPISchema();
+  }
+}

package/src/tagSpec.ts

@@ -13,8 +13,8 @@ export class TagSpecDefinition extends FeatureDefinition {
   public readonly tagDirectiveSpec: DirectiveSpecification;
   private readonly printedTagDefinition: string;
 
-  constructor(version: FeatureVersion) {
-    super(new FeatureUrl(tagIdentity, 'tag', version));
+  constructor(version: FeatureVersion, minimumFederationVersion?: FeatureVersion) {
+    super(new FeatureUrl(tagIdentity, 'tag', version), minimumFederationVersion);
     this.tagLocations = [
       DirectiveLocation.FIELD_DEFINITION,
       DirectiveLocation.OBJECT,
@@ -43,7 +43,7 @@ export class TagSpecDefinition extends FeatureDefinition {
       repeatable: true,
       args: [{ name: 'name', type: (schema) => new NonNullType(schema.stringType()) }],
       composes: true,
-      supergraphSpecification: () => TAG_VERSIONS.latest(),
+      supergraphSpecification: (fedVersion) => TAG_VERSIONS.getMinimumRequiredVersion(fedVersion),
     });
     this.registerDirective(this.tagDirectiveSpec);
   }
@@ -77,6 +77,6 @@ export class TagSpecDefinition extends FeatureDefinition {
 export const TAG_VERSIONS = new FeatureDefinitions<TagSpecDefinition>(tagIdentity)
   .add(new TagSpecDefinition(new FeatureVersion(0, 1)))
   .add(new TagSpecDefinition(new FeatureVersion(0, 2)))
-  .add(new TagSpecDefinition(new FeatureVersion(0, 3)));
+  .add(new TagSpecDefinition(new FeatureVersion(0, 3), new FeatureVersion(2, 0)));
 
 registerKnownFeature(TAG_VERSIONS);

package/src/utils.ts

@@ -431,3 +431,13 @@ export function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T> {
   return array.length > 0;
 }
 
+// We can switch to `Array.prototype.findLast` when we drop support for Node 16
+export function findLast<T>(array: T[], predicate: (t: T) => boolean): T | undefined {
+  for (let i = array.length - 1; i >= 0; i--) {
+    const t = array[i];
+    if (predicate(t)) {
+      return t;
+    }
+  }
+  return undefined;
+}