@apollo/federation-internals 2.9.0-connectors.8 → 2.10.0-alpha.0

package/src/specs/coreSpec.ts

@@ -547,6 +547,27 @@ export class CoreSpecDefinition extends FeatureDefinition {
     return feature.addElementsToSchema(schema);
   }
 
+  applyFeatureAsLink(schema: Schema, feature: FeatureDefinition, purpose?: CorePurpose, imports?: CoreImport[]): GraphQLError[] {
+    const existing = schema.schemaDefinition.appliedDirectivesOf(linkDirectiveDefaultName).find((link) => link.arguments().url === feature.toString());
+    if (existing) {
+      existing.remove();
+    }
+
+    const coreDirective = this.coreDirective(schema);
+    const args: LinkDirectiveArgs = {
+      url: feature.toString(),
+      import: (existing?.arguments().import ?? []).concat(imports?.map((i) => i.as ? { name: `@${i.name}`, as: `@${i.as}` } : `@${i.name}`)),
+      feature: undefined,
+    };
+
+    if (this.supportPurposes() && purpose) {
+      args.for = purpose;
+    }
+
+    schema.schemaDefinition.applyDirective(coreDirective, args);
+    return feature.addElementsToSchema(schema);
+  }
+
   extractFeatureUrl(args: CoreOrLinkDirectiveArgs): FeatureUrl {
     return FeatureUrl.parse(args[this.urlArgName()]!);
   }
@@ -597,7 +618,7 @@ export class FeatureDefinitions<T extends FeatureDefinition = FeatureDefinition>
     // this._definitions is already sorted with the most recent first
     // get the first definition that is compatible with the federation version
     // if the minimum version is not present, assume that we won't look for an older version
-    const def = this._definitions.find(def => def.minimumFederationVersion ? fedVersion >= def.minimumFederationVersion : true);
+    const def = this._definitions.find(def => def.minimumFederationVersion ? fedVersion.gte(def.minimumFederationVersion) : true);
     assert(def, `No compatible definition exists for federation version ${fedVersion}`);
 
     // note that it's necessary that we can only get versions that have the same major version as the latest,
@@ -649,7 +670,7 @@ export class FeatureVersion {
     let max: FeatureVersion | undefined;
 
     for (const version of versions) {
-      if (!max || version > max) {
+      if (!max || version.gt(max)) {
         max = version;
       }
     }

package/src/specs/costSpec.ts

@@ -0,0 +1,60 @@
+import { DirectiveLocation } from 'graphql';
+import { createDirectiveSpecification } from '../directiveAndTypeSpecification';
+import { FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from './coreSpec';
+import { ListType, NonNullType } from '../definitions';
+import { registerKnownFeature } from '../knownCoreFeatures';
+import { ARGUMENT_COMPOSITION_STRATEGIES } from '../argumentCompositionStrategies';
+
+export const costIdentity = 'https://specs.apollo.dev/cost';
+
+export class CostSpecDefinition extends FeatureDefinition {
+  constructor(version: FeatureVersion, readonly minimumFederationVersion: FeatureVersion) {
+    super(new FeatureUrl(costIdentity, 'cost', version), minimumFederationVersion);
+
+    this.registerDirective(createDirectiveSpecification({
+      name: 'cost',
+      locations: [
+        DirectiveLocation.ARGUMENT_DEFINITION,
+        DirectiveLocation.ENUM,
+        DirectiveLocation.FIELD_DEFINITION,
+        DirectiveLocation.INPUT_FIELD_DEFINITION,
+        DirectiveLocation.OBJECT,
+        DirectiveLocation.SCALAR
+      ],
+      args: [{ name: 'weight', type: (schema) => new NonNullType(schema.intType()), compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.MAX }],
+      composes: true,
+      repeatable: false,
+      supergraphSpecification: (fedVersion) => COST_VERSIONS.getMinimumRequiredVersion(fedVersion),
+    }));
+
+    this.registerDirective(createDirectiveSpecification({
+      name: 'listSize',
+      locations: [DirectiveLocation.FIELD_DEFINITION],
+      args: [
+        { name: 'assumedSize', type: (schema) => schema.intType(), compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.NULLABLE_MAX },
+        { name: 'slicingArguments', type: (schema) => new ListType(new NonNullType(schema.stringType())), compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.NULLABLE_UNION },
+        { name: 'sizedFields', type: (schema) => new ListType(new NonNullType(schema.stringType())), compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.NULLABLE_UNION },
+        { name: 'requireOneSlicingArgument', type: (schema) => schema.booleanType(), defaultValue: true, compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.NULLABLE_AND },
+      ],
+      composes: true,
+      repeatable: false,
+      supergraphSpecification: (fedVersion) => COST_VERSIONS.getMinimumRequiredVersion(fedVersion)
+    }));
+  }
+}
+
+export const COST_VERSIONS = new FeatureDefinitions<CostSpecDefinition>(costIdentity)
+  .add(new CostSpecDefinition(new FeatureVersion(0, 1), new FeatureVersion(2, 9)));
+
+registerKnownFeature(COST_VERSIONS);
+
+export interface CostDirectiveArguments {
+  weight: number;
+}
+
+export interface ListSizeDirectiveArguments {
+  assumedSize?: number;
+  slicingArguments?: string[];
+  sizedFields?: string[];
+  requireOneSlicingArgument?: boolean;
+}

package/src/specs/federationSpec.ts

@@ -19,6 +19,7 @@ import { AUTHENTICATED_VERSIONS } from "./authenticatedSpec";
 import { REQUIRES_SCOPES_VERSIONS } from "./requiresScopesSpec";
 import { POLICY_VERSIONS } from './policySpec';
 import { CONTEXT_VERSIONS } from './contextSpec';
+import { COST_VERSIONS } from "./costSpec";
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
@@ -44,6 +45,8 @@ export enum FederationDirectiveName {
   POLICY = 'policy',
   CONTEXT = 'context',
   FROM_CONTEXT = 'fromContext',
+  COST = 'cost',
+  LIST_SIZE = 'listSize',
 }
 
 const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
@@ -128,7 +131,7 @@ export class FederationSpecDefinition extends FeatureDefinition {
 
     this.registerSubFeature(INACCESSIBLE_VERSIONS.getMinimumRequiredVersion(version));
 
-    if (version >= (new FeatureVersion(2, 7))) {
+    if (version.gte(new FeatureVersion(2, 7))) {
       this.registerDirective(createDirectiveSpecification({
         name: FederationDirectiveName.OVERRIDE,
         locations: [DirectiveLocation.FIELD_DEFINITION],
@@ -174,6 +177,10 @@ export class FederationSpecDefinition extends FeatureDefinition {
     if (version.gte(new FeatureVersion(2, 8))) {
       this.registerSubFeature(CONTEXT_VERSIONS.find(new FeatureVersion(0, 1))!);
     }
+
+    if (version.gte(new FeatureVersion(2, 9))) {
+      this.registerSubFeature(COST_VERSIONS.find(new FeatureVersion(0, 1))!);
+    }
   }
 }
 
@@ -186,6 +193,8 @@ export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefiniti
   .add(new FederationSpecDefinition(new FeatureVersion(2, 5)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 6)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 7)))
-  .add(new FederationSpecDefinition(new FeatureVersion(2, 8)));
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 8)))
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 9)))
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 10)));
 
 registerKnownFeature(FEDERATION_VERSIONS);

package/src/supergraphs.ts

@@ -40,6 +40,8 @@ export const ROUTER_SUPPORTED_SUPERGRAPH_FEATURES = new Set([
   'https://specs.apollo.dev/policy/v0.1',
   'https://specs.apollo.dev/source/v0.1',
   'https://specs.apollo.dev/context/v0.1',
+  'https://specs.apollo.dev/cost/v0.1',
+  'https://specs.apollo.dev/connect/v0.1',
 ]);
 
 const coreVersionZeroDotOneUrl = FeatureUrl.parse('https://specs.apollo.dev/core/v0.1');
@@ -127,7 +129,7 @@ export class Supergraph {
     this.containedSubgraphs = extractSubgraphsNamesAndUrlsFromSupergraph(schema);
   }
 
-  static build(supergraphSdl: string | DocumentNode, options?: { supportedFeatures?: Set<string>, validateSupergraph?: boolean }) {
+  static build(supergraphSdl: string | DocumentNode, options?: { supportedFeatures?: Set<string> | null, 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 })