@apollo/federation-internals 2.0.0-alpha.2 → 2.0.0-alpha.6

package/src/definitions.ts

@@ -1,10 +1,10 @@
 import {
-  ArgumentNode,
+  ConstArgumentNode,
   ASTNode,
   buildASTSchema as buildGraphqlSchemaFromAST,
   DirectiveLocation,
-  DirectiveLocationEnum,
-  DirectiveNode,
+  ConstDirectiveNode,
+  ConstValueNode,
   DocumentNode,
   GraphQLError,
   GraphQLSchema,
@@ -19,7 +19,7 @@ import {
 } from "graphql";
 import { CoreDirectiveArgs, CoreSpecDefinition, CORE_VERSIONS, FeatureUrl, isCoreSpecDirectiveApplication, removeFeatureElements } from "./coreSpec";
 import { arrayEquals, assert, mapValues, MapWithCachedArrays, setValues } from "./utils";
-import { withDefaultValues, valueEquals, valueToString, valueToAST, variablesInValue, valueFromAST } from "./values";
+import { withDefaultValues, valueEquals, valueToString, valueToAST, variablesInValue, valueFromAST, valueNodeToConstValueNode } from "./values";
 import { removeInaccessibleElements } from "./inaccessibleSpec";
 import { printSchema, Options, defaultPrintOptions } from './print';
 import { sameType } from './types';
@@ -233,15 +233,15 @@ export function runtimeTypesIntersects(t1: CompositeType, t2: CompositeType): bo
   return false;
 }
 
-export const executableDirectiveLocations: DirectiveLocationEnum[] = [
-  'QUERY',
-  'MUTATION',
-  'SUBSCRIPTION',
-  'FIELD',
-  'FRAGMENT_DEFINITION',
-  'FRAGMENT_SPREAD',
-  'INLINE_FRAGMENT',
-  'VARIABLE_DEFINITION',
+export const executableDirectiveLocations: DirectiveLocation[] = [
+  DirectiveLocation.QUERY,
+  DirectiveLocation.MUTATION,
+  DirectiveLocation.SUBSCRIPTION,
+  DirectiveLocation.FIELD,
+  DirectiveLocation.FRAGMENT_DEFINITION,
+  DirectiveLocation.FRAGMENT_SPREAD,
+  DirectiveLocation.INLINE_FRAGMENT,
+  DirectiveLocation.VARIABLE_DEFINITION,
 ];
 
 /**
@@ -253,27 +253,27 @@ export function typeToAST(type: Type): TypeNode {
   switch (type.kind) {
     case 'ListType':
       return {
-        kind: 'ListType',
+        kind: Kind.LIST_TYPE,
         type: typeToAST(type.ofType)
       };
     case 'NonNullType':
       return {
-        kind: 'NonNullType',
+        kind: Kind.NON_NULL_TYPE,
         type: typeToAST(type.ofType) as NamedTypeNode | ListTypeNode
       };
     default:
       return {
-        kind: 'NamedType',
-        name: { kind: 'Name', value: type.name }
+        kind: Kind.NAMED_TYPE,
+        name: { kind: Kind.NAME, value: type.name }
       };
   }
 }
 
 export function typeFromAST(schema: Schema, node: TypeNode): Type {
   switch (node.kind) {
-    case 'ListType':
+    case Kind.LIST_TYPE:
       return new ListType(typeFromAST(schema, node.type));
-    case 'NonNullType':
+    case Kind.NON_NULL_TYPE:
       return new NonNullType(typeFromAST(schema, node.type) as NullableType);
     default:
       const type = schema.type(node.name.value);
@@ -339,14 +339,14 @@ export class DirectiveTargetElement<T extends DirectiveTargetElement<T>> {
     return toAdd;
   }
 
-  appliedDirectivesToDirectiveNodes() : DirectiveNode[] | undefined {
+  appliedDirectivesToDirectiveNodes() : ConstDirectiveNode[] | undefined {
     if (this.appliedDirectives.length == 0) {
       return undefined;
     }
 
     return this.appliedDirectives.map(directive => {
       return {
-        kind: 'Directive',
+        kind: Kind.DIRECTIVE,
         name: {
           kind: Kind.NAME,
           value: directive.name,
@@ -697,6 +697,26 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
     return toReturn;
   }
 
+  /**
+   * Removes this this definition _and_, recursively, any other elements that references this type and would be invalid
+   * after the removal.
+   *
+   * Note that contrarily to `remove()` (which this method essentially call recursively), this method leaves the schema
+   * valid (assuming it was valid beforehand) _unless_ all the schema ends up being removed through recursion (in which
+   * case this leaves an empty schema, and that is not technically valid).
+   *
+   * Also note that this method does _not_ necessarily remove all the elements that reference this type: for instance,
+   * if this type is an interface, objects implementing it will _not_ be removed, they will simply stop implementing
+   * the interface. In practice, this method mainly remove fields that were using the removed type (in either argument or
+   * return type), but it can also remove object/input object/interface if through such field removal some type ends up
+   * empty, and it can remove unions if through that removal process and union becomes empty.
+   */
+  removeRecursive(): void {
+    this.remove().forEach(ref => this.removeReferenceRecursive(ref));
+  }
+
+  protected abstract removeReferenceRecursive(ref: TReferencer): void;
+
   referencers(): readonly TReferencer[] {
     return setValues(this._referencers);
   }
@@ -787,14 +807,18 @@ export class BuiltIns {
   addBuiltInDirectives(schema: Schema) {
     for (const name of ['include', 'skip']) {
       this.addBuiltInDirective(schema, name)
-        .addLocations('FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT')
+        .addLocations(DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT)
         .addArgument('if', new NonNullType(schema.booleanType()));
     }
     this.addBuiltInDirective(schema, 'deprecated')
-      .addLocations('FIELD_DEFINITION', 'ENUM_VALUE', 'ARGUMENT_DEFINITION', 'INPUT_FIELD_DEFINITION')
-      .addArgument('reason', schema.stringType(), 'No longer supported');
+      .addLocations(
+        DirectiveLocation.FIELD_DEFINITION,
+        DirectiveLocation.ENUM_VALUE,
+        DirectiveLocation.ARGUMENT_DEFINITION,
+        DirectiveLocation.INPUT_FIELD_DEFINITION,
+      ).addArgument('reason', schema.stringType(), 'No longer supported');
     this.addBuiltInDirective(schema, 'specifiedBy')
-      .addLocations('SCALAR')
+      .addLocations(DirectiveLocation.SCALAR)
       .addArgument('url', new NonNullType(schema.stringType()));
   }
 
@@ -1365,7 +1389,7 @@ export class Schema {
 
     // TODO: we should ensure first that there is no undefined types (or maybe throw properly when printing the AST
     // and catching that properly).
-    let errors: GraphQLError[] = validateSDL(this.toAST(), undefined, this.builtIns.validationRules());
+    let errors = validateSDL(this.toAST(), undefined, this.builtIns.validationRules());
     errors = errors.concat(validateSchema(this));
 
     // We avoid adding federation-specific validations if the base schema is not proper graphQL as the later can easily trigger
@@ -1377,7 +1401,7 @@ export class Schema {
     }
 
     if (errors.length > 0) {
-      throw ErrGraphQLValidationFailed(errors);
+      throw ErrGraphQLValidationFailed(errors as GraphQLError[]);
     }
 
     this.isValidated = true;
@@ -1530,6 +1554,10 @@ export class ScalarType extends BaseNamedType<OutputTypeReferencer | InputTypeRe
   protected removeInnerElements(): void {
     // No inner elements
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer | InputTypeReferencer): void {
+    ref.remove();
+  }
 }
 
 export class InterfaceImplementation<T extends ObjectType | InterfaceType> extends BaseExtensionMember<T> {
@@ -1753,6 +1781,20 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
     const schema = this.schema();
     return schema.schemaDefinition.root('query')?.type === this;
   }
+
+  protected removeReferenceRecursive(ref: ObjectTypeReferencer): void {
+    // Note that the ref can also be a`SchemaDefinition`, but don't have anything to do then.
+    switch (ref.kind) {
+      case 'FieldDefinition':
+        ref.removeRecursive();
+        break;
+      case 'UnionType':
+        if (ref.membersCount() === 0) {
+          ref.removeRecursive();
+        }
+        break;
+    }
+  }
 }
 
 export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeReferencer> {
@@ -1771,6 +1813,14 @@ export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeRe
     const typeName = typeof type === 'string' ? type : type.name;
     return this.possibleRuntimeTypes().some(t => t.name == typeName);
   }
+
+  protected removeReferenceRecursive(ref: InterfaceTypeReferencer): void {
+    // Note that an interface can be referenced by an object/interface that implements it, but after remove(), said object/interface
+    // will simply not implement "this" anymore and we have nothing more to do.
+    if (ref.kind === 'FieldDefinition') {
+      ref.removeRecursive();
+    }
+  }
 }
 
 export class UnionMember extends BaseExtensionMember<UnionType> {
@@ -1895,6 +1945,10 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
   protected hasNonExtensionInnerElements(): boolean {
     return this.members().some(m => m.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer): void {
+    ref.removeRecursive();
+  }
 }
 
 export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
@@ -1949,6 +2003,10 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   protected hasNonExtensionInnerElements(): boolean {
     return this._values.some(v => v.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: OutputTypeReferencer): void {
+    ref.removeRecursive();
+  }
 }
 
 export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObjectType> {
@@ -2019,6 +2077,19 @@ export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObj
   protected hasNonExtensionInnerElements(): boolean {
     return this.fields().some(f => f.ofExtension() === undefined);
   }
+
+  protected removeReferenceRecursive(ref: InputTypeReferencer): void {
+    if (ref.kind === 'ArgumentDefinition') {
+      // Not only do we want to remove the argument, but we want to remove its parent. Technically, only removing the argument would
+      // leave the schema in a valid state so it would be an option, but this feel a bit too weird of a behaviour in practice for a
+      // method calling `removeRecursive`. And in particular, it would mean that if the argument is a directive definition one,
+      // we'd also have to update each of the directive application to remove the correspond argument. Removing the full directive
+      // definition (and all its applications) feels a bit more predictable.
+      ref.parent().removeRecursive();
+    } else {
+      ref.removeRecursive();
+    }
+  }
 }
 
 class BaseWrapperType<T extends Type> {
@@ -2192,6 +2263,19 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
     return [];
   }
 
+  /**
+   * Like `remove()`, but if this field was the last field of its parent type, the parent type is removed through its `removeRecursive` method.
+   */
+  removeRecursive(): void {
+    const parent = this._parent;
+    this.remove();
+    // Note that we exclude the union type here because it doesn't have the `fields()` method, but the only field unions can have is the __typename
+    // one and it cannot be removed, so remove() above will actually throw in practice before reaching this.
+    if (parent && !isUnionType(parent) && parent.fields().length === 0) {
+      parent.removeRecursive();
+    }
+  }
+
   toString(): string {
     const args = this._args.size == 0
       ? ""
@@ -2251,6 +2335,17 @@ export class InputFieldDefinition extends NamedSchemaElementWithType<InputType,
     return [];
   }
 
+  /**
+   * Like `remove()`, but if this field was the last field of its parent type, the parent type is removed through its `removeRecursive` method.
+   */
+  removeRecursive(): void {
+    const parent = this._parent;
+    this.remove();
+    if (parent && parent.fields().length === 0) {
+      parent.removeRecursive();
+    }
+  }
+
   toString(): string {
     const defaultStr = this.defaultValue === undefined ? "" : ` = ${valueToString(this.defaultValue, this.type)}`;
     return `${this.name}: ${this.type}${defaultStr}`;
@@ -2367,7 +2462,7 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
 
   private readonly _args: MapWithCachedArrays<string, ArgumentDefinition<DirectiveDefinition>> = new MapWithCachedArrays();
   repeatable: boolean = false;
-  private readonly _locations: DirectiveLocationEnum[] = [];
+  private readonly _locations: DirectiveLocation[] = [];
   private readonly _referencers: Set<Directive<SchemaElement<any, any>, TApplicationArgs>> = new Set();
 
   constructor(name: string, readonly isBuiltIn: boolean = false) {
@@ -2414,11 +2509,11 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     this._args.delete(name);
   }
 
-  get locations(): readonly DirectiveLocationEnum[] {
+  get locations(): readonly DirectiveLocation[] {
     return this._locations;
   }
 
-  addLocations(...locations: DirectiveLocationEnum[]): DirectiveDefinition {
+  addLocations(...locations: DirectiveLocation[]): DirectiveDefinition {
     let modified = false;
     for (const location of locations) {
       if (!this._locations.includes(location)) {
@@ -2437,10 +2532,17 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
   }
 
   addAllTypeLocations(): DirectiveDefinition {
-    return this.addLocations('SCALAR', 'OBJECT', 'INTERFACE', 'UNION', 'ENUM', 'INPUT_OBJECT');
+    return this.addLocations(
+      DirectiveLocation.SCALAR,
+      DirectiveLocation.OBJECT,
+      DirectiveLocation.INTERFACE,
+      DirectiveLocation.UNION,
+      DirectiveLocation.ENUM,
+      DirectiveLocation.INPUT_OBJECT,
+    );
   }
 
-  removeLocations(...locations: DirectiveLocationEnum[]): DirectiveDefinition {
+  removeLocations(...locations: DirectiveLocation[]): DirectiveDefinition {
     let modified = false;
     for (const location of locations) {
       const index = this._locations.indexOf(location);
@@ -2491,6 +2593,13 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     return toReturn;
   }
 
+  /**
+   * Removes this this directive definition _and_ all its applications.
+   */
+  removeRecursive(): void {
+    this.remove().forEach(ref => ref.remove());
+  }
+
   toString(): string {
     return `@${this.name}`;
   }
@@ -2588,7 +2697,7 @@ export class Directive<
     this.onModification();
   }
 
-  argumentsToAST(): ArgumentNode[] | undefined {
+  argumentsToAST(): ConstArgumentNode[] | undefined {
     const entries = Object.entries(this._args);
     if (entries.length === 0) {
       return undefined;
@@ -2598,9 +2707,9 @@ export class Directive<
     assert(definition, () => `Cannot convert arguments of detached directive ${this}`);
     return entries.map(([n, v]) => {
       return {
-        kind: 'Argument',
+        kind: Kind.ARGUMENT,
         name: { kind: Kind.NAME, value: n },
-        value: valueToAST(v, definition.argument(n)!.type!)!,
+        value: valueToAST(v, definition.argument(n)!.type!)! as ConstValueNode,
       };
     });
   }
@@ -2664,8 +2773,8 @@ export class Variable {
 
   toVariableNode(): VariableNode {
     return {
-      kind: 'Variable',
-      name: { kind: 'Name', value: this.name },
+      kind: Kind.VARIABLE,
+      name: { kind: Kind.NAME, value: this.name },
     }
   }
 
@@ -2719,12 +2828,14 @@ export class VariableDefinition extends DirectiveTargetElement<VariableDefinitio
   }
 
   toVariableDefinitionNode(): VariableDefinitionNode {
+    const ast = valueToAST(this.defaultValue, this.type);
+
     return {
-      kind: 'VariableDefinition',
+      kind: Kind.VARIABLE_DEFINITION,
       variable: this.variable.toVariableNode(),
       type: typeToAST(this.type),
-      defaultValue: valueToAST(this.defaultValue, this.type),
-      directives: this.appliedDirectivesToDirectiveNodes()
+      defaultValue: (ast !== undefined) ? valueNodeToConstValueNode(ast) : undefined,
+      directives: this.appliedDirectivesToDirectiveNodes(),
     }
   }