@apollo/federation-internals 2.4.1 → 2.4.3

package/src/definitions.ts

@@ -1078,16 +1078,7 @@ export class CoreFeatures {
         isImported: false,
       } : undefined;
     } else {
-      const directFeature = this.byAlias.get(element.name);
-      if (directFeature && isDirective) {
-        return {
-          feature: directFeature,
-          nameInFeature: directFeature.imports.find(imp => imp.as === `@${element.name}`)?.name.slice(1) ?? element.name,
-          isImported: true,
-        };
-      }
-
-      // Let's see if it's an import. If not, it's not associated to a declared feature.
+      // Let's first see if it's an import, as this would take precedence over directive implicitely named like their feature.
       const importName = isDirective ? '@' + element.name : element.name;
       const allFeatures = [this.coreItself, ...this.byIdentity.values()];
       for (const feature of allFeatures) {
@@ -1101,6 +1092,17 @@ export class CoreFeatures {
           }
         }
       }
+
+      // Otherwise, this may be the special directive having the same name as its feature.
+      const directFeature = this.byAlias.get(element.name);
+      if (directFeature && isDirective) {
+        return {
+          feature: directFeature,
+          nameInFeature: directFeature.imports.find(imp => imp.as === `@${element.name}`)?.name.slice(1) ?? element.name,
+          isImported: true,
+        };
+      }
+
       return undefined;
     }
   }
@@ -1113,22 +1115,22 @@ const graphQLBuiltInDirectivesSpecifications: readonly DirectiveSpecification[]
   createDirectiveSpecification({
     name: 'include',
     locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
-    argumentFct: (schema) => ({ args: [{ name: 'if', type: new NonNullType(schema.booleanType()) }], errors: [] })
+    args: [{ name: 'if', type: (schema) => new NonNullType(schema.booleanType()) }],
   }),
   createDirectiveSpecification({
     name: 'skip',
     locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
-    argumentFct: (schema) => ({ args: [{ name: 'if', type: new NonNullType(schema.booleanType()) }], errors: [] })
+    args: [{ name: 'if', type: (schema) => new NonNullType(schema.booleanType()) }],
   }),
   createDirectiveSpecification({
     name: 'deprecated',
     locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE, DirectiveLocation.ARGUMENT_DEFINITION, DirectiveLocation.INPUT_FIELD_DEFINITION],
-    argumentFct: (schema) => ({ args: [{ name: 'reason', type: schema.stringType(), defaultValue: 'No longer supported' }], errors: [] })
+    args: [{ name: 'reason', type: (schema) => schema.stringType(), defaultValue: 'No longer supported' }],
   }),
   createDirectiveSpecification({
     name: 'specifiedBy',
     locations: [DirectiveLocation.SCALAR],
-    argumentFct: (schema) => ({ args: [{ name: 'url', type: new NonNullType(schema.stringType()) }], errors: [] })
+    args: [{ name: 'url', type: (schema) => new NonNullType(schema.stringType()) }],
   }),
   // Note that @defer and @stream are unconditionally added to `Schema` even if they are technically "optional" built-in. _But_,
   // the `Schema#toGraphQLJSSchema` method has an option to decide if @defer/@stream should be included or not in the resulting
@@ -1136,13 +1138,10 @@ const graphQLBuiltInDirectivesSpecifications: readonly DirectiveSpecification[]
   createDirectiveSpecification({
     name: 'defer',
     locations: [DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
-    argumentFct: (schema) => ({
-      args: [
-        { name: 'label', type: schema.stringType() },
-        { name: 'if', type: new NonNullType(schema.booleanType()), defaultValue: true },
-      ],
-      errors: [],
-    })
+    args: [
+      { name: 'label', type: (schema) => schema.stringType() },
+      { name: 'if', type: (schema) => new NonNullType(schema.booleanType()), defaultValue: true },
+    ],
   }),
   // Adding @stream too so that it's know and we don't error out if it is queries. It feels like it would be weird to do so for @stream but not
   // @defer when both are defined in the same spec. That said, that does *not* mean we currently _implement_ @stream, we don't, and so putting
@@ -1150,14 +1149,11 @@ const graphQLBuiltInDirectivesSpecifications: readonly DirectiveSpecification[]
   createDirectiveSpecification({
     name: 'stream',
     locations: [DirectiveLocation.FIELD],
-    argumentFct: (schema) => ({
-      args: [
-        { name: 'label', type: schema.stringType() },
-        { name: 'initialCount', type: schema.intType(), defaultValue: 0 },
-        { name: 'if', type: new NonNullType(schema.booleanType()), defaultValue: true },
-      ],
-      errors: [],
-    })
+    args: [
+      { name: 'label', type: (schema) => schema.stringType() },
+      { name: 'initialCount', type: (schema) => schema.intType(), defaultValue: 0 },
+      { name: 'if', type: (schema) => new NonNullType(schema.booleanType()), defaultValue: true },
+    ],
   }),
 ];
 
@@ -1457,6 +1453,16 @@ export class Schema {
     return this._builtInTypes.get('ID')! as ScalarType;
   }
 
+  builtInScalarTypes(): ScalarType[] {
+    return [
+      this.intType(),
+      this.floatType(),
+      this.stringType(),
+      this.booleanType(),
+      this.idType(),
+    ];
+  }
+
   addType<T extends NamedType>(type: T): T {
     const existing = this.type(type.name);
     if (existing) {

package/src/directiveAndTypeSpecification.ts

@@ -21,10 +21,23 @@ import { ERRORS } from "./error";
 import { valueEquals, valueToString } from "./values";
 import { sameType } from "./types";
 import { arrayEquals, assert } from "./utils";
+import { ArgumentCompositionStrategy } from "./argumentCompositionStrategies";
+import { FeatureDefinition } from "./coreSpec";
 
 export type DirectiveSpecification = {
   name: string,
   checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+  composition?: DirectiveCompositionSpecification,
+}
+
+export type DirectiveCompositionSpecification = {
+  supergraphSpecification: () => FeatureDefinition,
+  argumentsMerger?: (schema: Schema) => ArgumentMerger | GraphQLError,
+}
+
+export type ArgumentMerger = {
+  merge: (argName: string, values: any[]) => any,
+  toString: () => string,
 }
 
 export type TypeSpecification = {
@@ -34,43 +47,117 @@ export type TypeSpecification = {
 
 export type ArgumentSpecification = {
   name: string,
-  type: InputType,
+  type: (schema: Schema, nameInSchema?: string) => InputType | GraphQLError[],
   defaultValue?: any,
 }
 
+export type DirectiveArgumentSpecification = ArgumentSpecification & {
+  compositionStrategy?: ArgumentCompositionStrategy,
+}
+
 export type FieldSpecification = {
   name: string,
   type: OutputType,
-  args?: ArgumentSpecification[],
-};
+  args?: ResolvedArgumentSpecification[],
+}
+
+type ResolvedArgumentSpecification = {
+  name: string,
+  type: InputType,
+  defaultValue?: any,
+}
 
 export function createDirectiveSpecification({
   name,
   locations,
   repeatable = false,
-  argumentFct = undefined,
+  args = [],
+  composes = false,
+  supergraphSpecification = undefined,
 }: {
   name: string,
   locations: DirectiveLocation[],
   repeatable?: boolean,
-  argumentFct?: (schema: Schema, nameInSchema?: string) => { args: ArgumentSpecification[], errors: GraphQLError[] },
+  args?: DirectiveArgumentSpecification[],
+  composes?: boolean,
+  supergraphSpecification?: () => FeatureDefinition,
 }): DirectiveSpecification {
+  let composition: DirectiveCompositionSpecification | undefined = undefined;
+  if (composes) {
+    assert(supergraphSpecification, `Should provide a @link specification to use in supergraph for directive @${name} if it composes`);
+    const argStrategies = new Map(args.filter((arg) => arg.compositionStrategy).map((arg) => [arg.name, arg.compositionStrategy!]));
+    let argumentsMerger: ((schema: Schema) => ArgumentMerger | GraphQLError) | undefined = undefined;
+    if (argStrategies.size > 0) {
+      assert(!repeatable, () => `Invalid directive specification for @${name}: @${name} is repeatable and should not define composition strategy for its arguments`);
+      assert(argStrategies.size === args.length, () => `Invalid directive specification for @${name}: not all arguments define a composition strategy`);
+      argumentsMerger = (schema) => {
+        // Validate that the arguments have compatible types with the declared strategies (a bit unfortunate that we can't do this until
+        // we have a schema but well, not a huge deal either).
+        for (const { name: argName, type } of args) {
+          const strategy = argStrategies.get(argName);
+          // Note that we've built `argStrategies` from the declared args and checked that all argument had a strategy, so it would be
+          // a bug in the code if we didn't get a strategy (not an issue in the directive declaration).
+          assert(strategy, () => `Should have a strategy for ${argName}`);
+          const argType = type(schema);
+          // By the time we call this, the directive should have been added to the schema and so getting the type should not raise errors.
+          assert(!Array.isArray(argType), () => `Should have gotten error getting type for @${name}(${argName}:), but got ${argType}`)
+          const strategyTypes = strategy.supportedTypes(schema);
+          if (!strategyTypes.some((t) => sameType(t, argType))) {
+            return new GraphQLError(
+              `Invalid composition strategy ${strategy.name} for argument @${name}(${argName}:) of type ${argType}; `
+              + `${strategy.name} only supports type(s) ${strategyTypes.join(', ')}`
+            );
+          }
+        };
+        return {
+          merge: (argName, values) => {
+            const strategy = argStrategies.get(argName);
+            assert(strategy, () => `Should have a strategy for ${argName}`);
+            return strategy.mergeValues(values);
+          },
+          toString: () => {
+            if (argStrategies.size === 0) {
+              return "<none>";
+            }
+            return '{ ' + [...argStrategies.entries()].map(([arg, strategy]) => `"${arg}": ${strategy.name}`).join(', ') + ' }';
+          }
+        };
+      }
+    }
+    composition = {
+      supergraphSpecification,
+      argumentsMerger,
+    };
+  }
+
   return {
     name,
+    composition,
     checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
       const actualName = nameInSchema ?? name;
-      const {args, errors} = argumentFct ? argumentFct(schema, actualName) : { args: [], errors: []};
+      const { resolvedArgs, errors } = args.reduce<{ resolvedArgs: (ResolvedArgumentSpecification & { compositionStrategy?: ArgumentCompositionStrategy })[], errors: GraphQLError[] }>(
+        ({ resolvedArgs, errors }, arg) => {
+          const typeOrErrors = arg.type(schema, actualName);
+          if (Array.isArray(typeOrErrors)) {
+            errors.push(...typeOrErrors);
+          } else {
+            resolvedArgs.push({ ...arg, type: typeOrErrors });
+          }
+          return { resolvedArgs, errors };
+        },
+        { resolvedArgs: [], errors: [] }
+      );
       if (errors.length > 0) {
         return errors;
       }
       const existing = schema.directive(actualName);
       if (existing) {
-        return ensureSameDirectiveStructure({name: actualName, locations, repeatable, args}, existing);
+        return ensureSameDirectiveStructure({ name: actualName, locations, repeatable, args: resolvedArgs }, existing);
       } else {
         const directive = schema.addDirectiveDefinition(new DirectiveDefinition(actualName, asBuiltIn));
         directive.repeatable = repeatable;
         directive.addLocations(...locations);
-        for (const { name, type, defaultValue } of args) {
+        for (const { name, type, defaultValue } of resolvedArgs) {
           directive.addArgument(name, type, defaultValue);
         }
         return [];
@@ -95,7 +182,7 @@ export function createScalarTypeSpecification({ name }: { name: string }): TypeS
   }
 }
 
-export function createObjectTypeSpecification({ 
+export function createObjectTypeSpecification({
   name,
   fieldsFct,
 }: {
@@ -156,7 +243,7 @@ export function createObjectTypeSpecification({
   }
 }
 
-export function createUnionTypeSpecification({ 
+export function createUnionTypeSpecification({
   name,
   membersFct,
 }: {
@@ -210,7 +297,7 @@ export function createEnumTypeSpecification({
   values,
 }: {
   name: string,
-  values: { name: string, description?: string}[],
+  values: { name: string, description?: string }[],
 }): TypeSpecification {
   return {
     name,
@@ -234,7 +321,7 @@ export function createEnumTypeSpecification({
         return errors;
       } else {
         const type = schema.addType(new EnumType(actualName, asBuiltIn));
-        for (const {name, description} of values) {
+        for (const { name, description } of values) {
           type.addValue(name).description = description;
         }
         return [];
@@ -259,7 +346,7 @@ function ensureSameDirectiveStructure(
     name: string,
     locations: DirectiveLocation[],
     repeatable: boolean,
-    args: ArgumentSpecification[]
+    args: ResolvedArgumentSpecification[]
   },
   actual: DirectiveDefinition<any>,
 ): GraphQLError[] {
@@ -285,7 +372,7 @@ function ensureSameDirectiveStructure(
 function ensureSameArguments(
   expected: {
     name: string,
-    args?: ArgumentSpecification[]
+    args?: ResolvedArgumentSpecification[]
   },
   actual: { argument(name: string): ArgumentDefinition<any> | undefined, arguments(): readonly ArgumentDefinition<any>[] },
   what: string,

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);
+}