@apollo/federation-internals 2.4.0 → 2.4.2

package/src/federation.ts

@@ -80,6 +80,8 @@ import {
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
 import { didYouMean, suggestionList } from "./suggestions";
+import { coreFeatureDefinitionIfKnown } from "./knownCoreFeatures";
+import { joinIdentity } from "./joinSpec";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
@@ -110,7 +112,6 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
 const FEDERATION_VALIDATION_RULES = specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
 
 const ALL_DEFAULT_FEDERATION_DIRECTIVE_NAMES: string[] = Object.values(FederationDirectiveName);
-
 function validateFieldSetSelections({
   directiveName,
   selectionSet,
@@ -1342,12 +1343,14 @@ function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
     }
   }
 
-  return FEDERATION1_TYPES.map((spec) => spec.checkOrAdd(schema, '_' + spec.name))
+  const errors = FEDERATION1_TYPES.map((spec) => spec.checkOrAdd(schema, '_' + spec.name))
     .concat(FEDERATION1_DIRECTIVES.map((spec) => spec.checkOrAdd(schema)))
     .flat();
+
+  return errors.length === 0 ? expandKnownFeatures(schema) : errors;
 }
 
-function completeFed2SubgraphSchema(schema: Schema) {
+function completeFed2SubgraphSchema(schema: Schema): GraphQLError[] {
   const coreFeatures = schema.coreFeatures;
   assert(coreFeatures, 'This method should not have been called on a non-core schema');
 
@@ -1362,7 +1365,33 @@ function completeFed2SubgraphSchema(schema: Schema) {
     )];
   }
 
-  return spec.addElementsToSchema(schema);
+  const errors = spec.addElementsToSchema(schema);
+  return errors.length === 0 ? expandKnownFeatures(schema) : errors;
+}
+
+function expandKnownFeatures(schema: Schema): GraphQLError[] {
+  const coreFeatures = schema.coreFeatures;
+  if (!coreFeatures) {
+    return [];
+  }
+
+  let errors: GraphQLError[] = [];
+  for (const feature of coreFeatures.allFeatures()) {
+    // We should already have dealt with the core/link spec and federation at this point. Also, we shouldn't have the `join` spec in subgraphs,
+    // but some tests play with the idea and currently the join spec is implemented in a way that is not idempotent (it doesn't use
+    // `DirectiveSpecification.checkAndAdd`; we should clean it up at some point, but not exactly urgent).
+    if (feature === coreFeatures.coreItself || feature.url.identity === federationIdentity  || feature.url.identity === joinIdentity) {
+      continue;
+    }
+
+    const spec = coreFeatureDefinitionIfKnown(feature.url);
+    if (!spec) {
+      continue;
+    }
+
+    errors = errors.concat(spec.addElementsToSchema(schema));
+  }
+  return errors;
 }
 
 export function parseFieldSetArgument({

package/src/federationSpec.ts

@@ -8,11 +8,9 @@ import {
   ArgumentSpecification,
   createDirectiveSpecification,
   createScalarTypeSpecification,
-  DirectiveSpecification,
-  TypeSpecification,
 } from "./directiveAndTypeSpecification";
-import { DirectiveLocation, GraphQLError } from "graphql";
-import { assert, MapWithCachedArrays } from "./utils";
+import { DirectiveLocation } from "graphql";
+import { assert } from "./utils";
 import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
 import { registerKnownFeature } from "./knownCoreFeatures";
@@ -40,17 +38,16 @@ export enum FederationDirectiveName {
 
 const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
 
+const fieldsArgument: ArgumentSpecification = { name: 'fields', type: (schema) => fieldSetType(schema) };
+
 const keyDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.KEY,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
   repeatable: true,
-  argumentFct: (schema) => ({
-    args: [
-      fieldsArgument(schema),
-      { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
-    ],
-    errors: [],
-  }),
+  args: [
+    fieldsArgument,
+    { name: 'resolvable', type: (schema) => schema.booleanType(), defaultValue: true },
+  ]
 });
 
 const extendsDirectiveSpec = createDirectiveSpecification({
@@ -61,28 +58,19 @@ const extendsDirectiveSpec = createDirectiveSpecification({
 const externalDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.EXTERNAL,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [{ name: 'reason', type: schema.stringType() }],
-    errors: [],
-  }),
+  args: [{ name: 'reason', type: (schema) => schema.stringType() }],
 });
 
 const requiresDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.REQUIRES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [fieldsArgument(schema)],
-    errors: [],
-  }),
+  args: [fieldsArgument],
 });
 
 const providesDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.PROVIDES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [fieldsArgument(schema)],
-    errors: [],
-  }),
+  args: [fieldsArgument],
 });
 
 const legacyFederationTypes = [
@@ -103,9 +91,6 @@ const legacyFederationDirectives = [
 export const FEDERATION1_TYPES = legacyFederationTypes;
 export const FEDERATION1_DIRECTIVES = legacyFederationDirectives;
 
-function fieldsArgument(schema: Schema): ArgumentSpecification {
-  return { name: 'fields', type: fieldSetType(schema) };
-}
 
 function fieldSetType(schema: Schema): InputType {
   const metadata = federationMetadata(schema);
@@ -114,9 +99,6 @@ function fieldSetType(schema: Schema): InputType {
 }
 
 export class FederationSpecDefinition extends FeatureDefinition {
-  private readonly _directiveSpecs = new MapWithCachedArrays<string, DirectiveSpecification>();
-  private readonly _typeSpecs = new MapWithCachedArrays<string, TypeSpecification>();
-
   constructor(version: FeatureVersion) {
     super(new FeatureUrl(federationIdentity, 'federation', version));
 
@@ -139,10 +121,7 @@ export class FederationSpecDefinition extends FeatureDefinition {
     this.registerDirective(createDirectiveSpecification({
       name: FederationDirectiveName.OVERRIDE,
       locations: [DirectiveLocation.FIELD_DEFINITION],
-      argumentFct: (schema) => ({
-        args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
-        errors: [],
-      }),
+      args: [{ name: 'from', type: (schema) => new NonNullType(schema.stringType()) }],
     }));
 
     if (version >= (new FeatureVersion(2, 1))) {
@@ -150,10 +129,7 @@ export class FederationSpecDefinition extends FeatureDefinition {
         name: FederationDirectiveName.COMPOSE_DIRECTIVE,
         locations: [DirectiveLocation.SCHEMA],
         repeatable: true,
-        argumentFct: (schema) => ({
-          args: [{ name: 'name', type: schema.stringType() }],
-          errors: [],
-        }),
+        args: [{ name: 'name', type: (schema) => schema.stringType() }],
       }));
     }
 
@@ -167,42 +143,6 @@ export class FederationSpecDefinition extends FeatureDefinition {
       );
     }
   }
-
-  private registerDirective(spec: DirectiveSpecification) {
-    this._directiveSpecs.set(spec.name, spec);
-  }
-
-  private registerType(spec: TypeSpecification) {
-    this._typeSpecs.set(spec.name, spec);
-  }
-
-  directiveSpecs(): readonly DirectiveSpecification[] {
-    return this._directiveSpecs.values();
-  }
-
-  typeSpecs(): readonly TypeSpecification[] {
-    return this._typeSpecs.values();
-  }
-
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    const feature = this.featureInSchema(schema);
-    assert(feature, 'The federation specification should have been added to the schema before this is called');
-
-    let errors: GraphQLError[] = [];
-    for (const type of this.typeSpecs()) {
-      errors = errors.concat(this.addTypeSpec(schema, type));
-    }
-
-    for (const directive of this.directiveSpecs()) {
-      errors = errors.concat(this.addDirectiveSpec(schema, directive));
-    }
-    return errors;
-  }
-
-  allElementNames(): string[] {
-    return this.directiveSpecs().map((spec) => `@${spec.name}`)
-      .concat(this.typeSpecs().map((spec) => spec.name));
-  }
 }
 
 export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefinition>(federationIdentity)

package/src/inaccessibleSpec.ts

@@ -62,17 +62,16 @@ export class InaccessibleSpecDefinition extends FeatureDefinition {
     this.inaccessibleDirectiveSpec = createDirectiveSpecification({
       name: 'inaccessible',
       locations: this.inaccessibleLocations,
+      composes: true,
+      supergraphSpecification: () => INACCESSIBLE_VERSIONS.latest(),
     });
+    this.registerDirective(this.inaccessibleDirectiveSpec);
   }
 
   isV01() {
     return this.version.equals(new FeatureVersion(0, 1));
   }
 
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    return this.addDirectiveSpec(schema, this.inaccessibleDirectiveSpec);
-  }
-
   inaccessibleDirective(schema: Schema): DirectiveDefinition<Record<string, never>> | undefined {
     return this.directive(schema, 'inaccessible');
   }
@@ -89,10 +88,6 @@ export class InaccessibleSpecDefinition extends FeatureDefinition {
     return undefined;
   }
 
-  allElementNames(): string[] {
-    return ['@inaccessible'];
-  }
-
   get defaultCorePurpose(): CorePurpose | undefined {
     return 'SECURITY';
   }
@@ -891,9 +886,7 @@ function getInputType(element: SchemaElementWithDefaultValue): InputType {
 // similar to the "Values of Correct Type" validation in the GraphQL spec.
 // However, there are two noteable differences:
 // 1. Variable references are not allowed.
-// 2. Scalar values are not required to be coercible (due to machine-specific
-//    differences in input coercion rules).
-//
+// 2. Scalar values are not required to be coercible (due to machine-specific differences in input coercion rules).
 // As it turns out, building a Schema object validates this (and a bit more)
 // already, so in the interests of not duplicating validations/keeping the logic
 // centralized, this code assumes the input values it receives satisfy the above

package/src/index.ts

@@ -18,3 +18,6 @@ export * from './error';
 export * from './schemaUpgrader';
 export * from './suggestions';
 export * from './graphQLJSSchemaToAST';
+export * from './directiveAndTypeSpecification';
+export { coreFeatureDefinitionIfKnown } from './knownCoreFeatures';
+export * from './argumentCompositionStrategies';

package/src/knownCoreFeatures.ts

@@ -11,3 +11,12 @@ export function registerKnownFeature(definitions: FeatureDefinitions) {
 export function coreFeatureDefinitionIfKnown(url: FeatureUrl): FeatureDefinition | undefined {
   return registeredFeatures.get(url.identity)?.find(url.version);
 }
+
+/**
+ * Removes a feature from the set of known features.
+ *
+ * This exists purely for testing purposes. There is no reason to unregistered features otherwise.
+ */
+export function unregisterKnownFeatures(definitions: FeatureDefinitions) {
+  registeredFeatures.delete(definitions.identity);
+}