@apollo/federation-internals 2.0.0-preview.7 → 2.0.0

package/src/federationSpec.ts

@@ -9,10 +9,12 @@ import {
   createDirectiveSpecification,
   createScalarTypeSpecification,
 } from "./directiveAndTypeSpecification";
-import { DirectiveLocation } from "graphql";
+import { DirectiveLocation, GraphQLError } from "graphql";
 import { assert } from "./utils";
-import { tagLocations } from "./tagSpec";
+import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
+import { registerKnownFeature } from "./knownCoreFeatures";
+import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
@@ -22,10 +24,13 @@ export const keyDirectiveSpec = createDirectiveSpecification({
   name:'key',
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
   repeatable: true,
-  argumentFct: (schema) => [
-    fieldsArgument(schema),
-    { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
-  ]
+  argumentFct: (schema) => ({
+    args: [
+      fieldsArgument(schema),
+      { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
+    ],
+    errors: [],
+  }),
 });
 
 export const extendsDirectiveSpec = createDirectiveSpecification({
@@ -36,22 +41,28 @@ export const extendsDirectiveSpec = createDirectiveSpecification({
 export const externalDirectiveSpec = createDirectiveSpecification({
   name:'external',
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
+  argumentFct: (schema) => ({
+    args: [{ name: 'reason', type: schema.stringType() }],
+    errors: [],
+  }),
 });
 
 export const requiresDirectiveSpec = createDirectiveSpecification({
   name:'requires',
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => {
-    return [fieldsArgument(schema)];
-  }
+  argumentFct: (schema) => ({
+    args: [fieldsArgument(schema)],
+    errors: [],
+  }),
 });
 
 export const providesDirectiveSpec = createDirectiveSpecification({
   name:'provides',
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => {
-    return [fieldsArgument(schema)];
-  }
+  argumentFct: (schema) => ({
+    args: [fieldsArgument(schema)],
+    errors: [],
+  }),
 });
 
 export const shareableDirectiveSpec = createDirectiveSpecification({
@@ -59,13 +70,13 @@ export const shareableDirectiveSpec = createDirectiveSpecification({
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
 });
 
-export const tagDirectiveSpec = createDirectiveSpecification({
-  name:'tag',
-  locations: tagLocations,
-  repeatable: true,
-  argumentFct: (schema) => {
-    return [{ name: 'name', type: new NonNullType(schema.stringType()) }];
-  }
+export const overrideDirectiveSpec = createDirectiveSpecification({
+  name: 'override',
+  locations: [DirectiveLocation.FIELD_DEFINITION],
+  argumentFct: (schema) => ({
+    args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
+    errors: [],
+  }),
 });
 
 function fieldsArgument(schema: Schema): ArgumentSpecification {
@@ -78,17 +89,28 @@ function fieldSetType(schema: Schema): InputType {
   return new NonNullType(metadata.fieldSetType());
 }
 
+export const FEDERATION2_ONLY_SPEC_DIRECTIVES = [
+  shareableDirectiveSpec,
+  INACCESSIBLE_VERSIONS.latest().inaccessibleDirectiveSpec,
+  overrideDirectiveSpec,
+];
+
 // Note that this is only used for federation 2+ (federation 1 adds the same directive, but not through a core spec).
 export const FEDERATION2_SPEC_DIRECTIVES = [
   keyDirectiveSpec,
   requiresDirectiveSpec,
   providesDirectiveSpec,
   externalDirectiveSpec,
-  shareableDirectiveSpec,
-  tagDirectiveSpec,
+  TAG_VERSIONS.latest().tagDirectiveSpec,
   extendsDirectiveSpec, // TODO: should we stop supporting that?
+  ...FEDERATION2_ONLY_SPEC_DIRECTIVES,
 ];
 
+// Note that this is meant to contain _all_ federation directive names ever supported, regardless of which version.
+// But currently, fed2 directives are a superset of fed1's so ... (but this may change if we stop supporting `@extends`
+// in fed2).
+export const ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES = FEDERATION2_SPEC_DIRECTIVES.map((spec) => spec.name);
+
 export const FEDERATION_SPEC_TYPES = [
   fieldSetTypeSpec,
 ]
@@ -98,17 +120,27 @@ export class FederationSpecDefinition extends FeatureDefinition {
     super(new FeatureUrl(federationIdentity, 'federation', version));
   }
 
-  addElementsToSchema(schema: Schema) {
+  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');
 
-    fieldSetTypeSpec.checkOrAdd(schema, feature.typeNameInSchema(fieldSetTypeSpec.name));
+    let errors: GraphQLError[] = [];
+    errors = errors.concat(this.addTypeSpec(schema, fieldSetTypeSpec));
 
     for (const directive of FEDERATION2_SPEC_DIRECTIVES) {
-      directive.checkOrAdd(schema, feature.directiveNameInSchema(directive.name));
+      errors = errors.concat(this.addDirectiveSpec(schema, directive));
     }
+    return errors;
+  }
+
+  allElementNames(): string[] {
+    return FEDERATION2_SPEC_DIRECTIVES.map((spec) => `@${spec.name}`).concat([
+      fieldSetTypeSpec.name,
+    ])
   }
 }
 
 export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefinition>(federationIdentity)
   .add(new FederationSpecDefinition(new FeatureVersion(2, 0)));
+
+registerKnownFeature(FEDERATION_VERSIONS);