@apollo/federation-internals 2.8.1 → 2.8.3-beta.0

package/src/definitions.ts

@@ -59,6 +59,8 @@ import { coreFeatureDefinitionIfKnown } from "./knownCoreFeatures";
 const validationErrorCode = 'GraphQLValidationFailed';
 const DEFAULT_VALIDATION_ERROR_MESSAGE = 'The schema is not a valid GraphQL schema.';
 
+const EMPTY_SET = new Set<never>();
+
 export const ErrGraphQLValidationFailed = (causes: GraphQLError[], message: string = DEFAULT_VALIDATION_ERROR_MESSAGE) =>
   aggregateError(validationErrorCode, message, causes);
 
@@ -660,7 +662,7 @@ export abstract class NamedSchemaElement<TOwnType extends NamedSchemaElement<TOw
 }
 
 abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSchemaElement<TOwnType, Schema, TReferencer>> extends NamedSchemaElement<TOwnType, Schema, TReferencer> {
-  protected _referencers?: TReferencer[];
+  protected _referencers?: Set<TReferencer>;
   protected _extensions?: Extension<TOwnType>[];
   public preserveEmptyDefinition: boolean = false;
 
@@ -669,19 +671,12 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
   }
 
   private addReferencer(referencer: TReferencer) {
-    if (this._referencers) {
-      if (!this._referencers.includes(referencer)) {
-        this._referencers.push(referencer);
-      }
-    } else {
-      this._referencers = [ referencer ];
-    }
+    this._referencers ??= new Set();
+    this._referencers.add(referencer);
   }
 
   private removeReferencer(referencer: TReferencer) {
-    if (this._referencers) {
-      removeArrayElement(referencer, this._referencers);
-    }
+    this._referencers?.delete(referencer)
   }
 
   get coordinate(): string {
@@ -789,10 +784,11 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
     this.removeAppliedDirectives();
     this.removeInnerElements();
     // Remove this type's references.
-    const toReturn = this._referencers?.map(r => {
+    const toReturn: TReferencer[] = [];
+    this._referencers?.forEach(r => {
       SchemaElement.prototype['removeTypeReferenceInternal'].call(r, this);
-      return r;
-    }) ?? [];
+      toReturn.push(r);
+    });
     this._referencers = undefined;
     // Remove this type from its parent schema.
     Schema.prototype['removeTypeInternal'].call(this._parent, this);
@@ -820,8 +816,8 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
 
   protected abstract removeReferenceRecursive(ref: TReferencer): void;
 
-  referencers(): readonly TReferencer[] {
-    return this._referencers ?? [];
+  referencers(): ReadonlySet<TReferencer> {
+    return this._referencers ?? EMPTY_SET;
   }
 
   isReferenced(): boolean {
@@ -1261,7 +1257,7 @@ export class Schema {
     if (!this.apiSchema) {
       this.validate();
 
-      const apiSchema = this.clone();
+      const apiSchema = this.clone(undefined, false);
 
       // As we compute the API schema of a supergraph, we want to ignore explicit definitions of `@defer` and `@stream` because
       // those correspond to the merging of potential definitions from the subgraphs, but whether the supergraph API schema
@@ -1611,9 +1607,9 @@ export class Schema {
     this.isValidated = true;
   }
 
-  clone(builtIns?: SchemaBlueprint): Schema {
+  clone(builtIns?: SchemaBlueprint, cloneJoinDirectives: boolean = true): Schema {
     const cloned = new Schema(builtIns ?? this.blueprint);
-    copy(this, cloned);
+    copy(this, cloned, cloneJoinDirectives);
     if (this.isValidated) {
       cloned.assumeValid();
     }
@@ -2124,7 +2120,13 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
   }
 
   unionsWhereMember(): readonly UnionType[] {
-    return this._referencers?.filter<UnionType>((r): r is UnionType => r instanceof BaseNamedType && isUnionType(r)) ?? [];
+    const unions: UnionType[] = [];
+    this._referencers?.forEach((r) => {
+      if (r instanceof BaseNamedType && isUnionType(r)) {
+        unions.push(r);
+      }
+    });
+    return unions;
   }
 }
 
@@ -2133,7 +2135,13 @@ export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeRe
   readonly astDefinitionKind = Kind.INTERFACE_TYPE_DEFINITION;
 
   allImplementations(): (ObjectType | InterfaceType)[] {
-    return this.referencers().filter(ref => ref.kind === 'ObjectType' || ref.kind === 'InterfaceType') as (ObjectType | InterfaceType)[];
+    const implementations: (ObjectType | InterfaceType)[] = [];
+    this.referencers().forEach(ref => {
+      if (ref.kind === 'ObjectType' || ref.kind === 'InterfaceType') {
+        implementations.push(ref);
+      }
+    });
+    return implementations;
   }
 
   possibleRuntimeTypes(): readonly ObjectType[] {
@@ -2291,7 +2299,7 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
 export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   readonly kind = 'EnumType' as const;
   readonly astDefinitionKind = Kind.ENUM_TYPE_DEFINITION;
-  protected readonly _values: EnumValue[] = [];
+  private _values = new Map<string, EnumValue>();
 
   get values(): readonly EnumValue[] {
     // Because our abstractions are mutable, and removal is done by calling
@@ -2299,11 +2307,11 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
     // try to iterate on the result of this method and call `remove()` on
     // some of the return value based on some condition. But this will break
     // in an error-prone way if we don't copy, so we do.
-    return Array.from(this._values);
+    return Array.from(this._values.values());
   }
-
+  
   value(name: string): EnumValue | undefined {
-    return this._values.find(v => v.name === name);
+    return this._values.get(name);
   }
 
   addValue(value: EnumValue): EnumValue;
@@ -2319,7 +2327,7 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
     }
     const existing = this.value(toAdd.name);
     if (!existing) {
-      this._values.push(toAdd);
+      this._values.set(toAdd.name, toAdd);
       Element.prototype['setParent'].call(toAdd, this);
       this.onModification();
       return toAdd;
@@ -2333,7 +2341,7 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   }
 
   private removeValueInternal(value: EnumValue) {
-    removeArrayElement(value, this._values);
+    this._values.delete(value.name);
   }
 
   protected removeInnerElements(): void {
@@ -2345,7 +2353,7 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   }
 
   protected hasNonExtensionInnerElements(): boolean {
-    return this._values.some(v => v.ofExtension() === undefined);
+    return Array.from(this._values.values()).some(v => v.ofExtension() === undefined);
   }
 
   protected removeReferenceRecursive(ref: OutputTypeReferencer): void {
@@ -2353,7 +2361,9 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   }
 
   protected removeInnerElementsExtensions(): void {
-    this._values.forEach(v => v.removeOfExtension());
+    for (const v of this._values.values()) {
+      v.removeOfExtension();
+    }
   }
 }
 
@@ -2893,7 +2903,7 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
   private _args?: MapWithCachedArrays<string, ArgumentDefinition<DirectiveDefinition>>;
   repeatable: boolean = false;
   private readonly _locations: DirectiveLocation[] = [];
-  private _referencers?: Directive<SchemaElement<any, any>, TApplicationArgs>[];
+  private _referencers?: Set<Directive<SchemaElement<any, any>, TApplicationArgs>>;
 
   constructor(name: string, readonly isBuiltIn: boolean = false) {
     super(name);
@@ -2997,25 +3007,19 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     return this.locations.some((loc) => isTypeSystemDirectiveLocation(loc));
   }
 
-  applications(): readonly Directive<SchemaElement<any, any>, TApplicationArgs>[] {
-    return this._referencers ?? [];
+  applications(): ReadonlySet<Directive<SchemaElement<any, any>, TApplicationArgs>> {
+    this._referencers ??= new Set();
+    return this._referencers;
   }
 
   private addReferencer(referencer: Directive<SchemaElement<any, any>, TApplicationArgs>) {
     assert(referencer, 'Referencer should exists');
-    if (this._referencers) {
-      if (!this._referencers.includes(referencer)) {
-        this._referencers.push(referencer);
-      }
-    } else {
-      this._referencers = [ referencer ];
-    }
+    this._referencers ??= new Set();
+    this._referencers.add(referencer);
   }
 
   private removeReferencer(referencer: Directive<SchemaElement<any, any>, TApplicationArgs>) {
-    if (this._referencers) {
-      removeArrayElement(referencer, this._referencers);
-    }
+    this._referencers?.delete(referencer);
   }
 
   protected removeTypeReference(type: NamedType) {
@@ -3046,7 +3050,7 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     // doesn't store a link to that definition. Instead, we fetch the definition
     // from the schema when requested. So we don't have to do anything on the
     // referencers other than clear them (and return the pre-cleared set).
-    const toReturn = this._referencers ?? [];
+    const toReturn = Array.from(this._referencers ?? []);
     this._referencers = undefined;
     // Remove this directive definition from its parent schema.
     Schema.prototype['removeDirectiveInternal'].call(this._parent, this);
@@ -3596,7 +3600,7 @@ export function copyDirectiveDefinitionToSchema({
   );
 }
 
-function copy(source: Schema, dest: Schema) {
+function copy(source: Schema, dest: Schema, cloneJoinDirectives: boolean) {
   // We shallow copy types first so any future reference to any of them can be dereferenced.
   for (const type of typesToCopy(source, dest)) {
     dest.addType(newNamedType(type.kind, type.name));
@@ -3613,7 +3617,7 @@ function copy(source: Schema, dest: Schema) {
 
   copySchemaDefinitionInner(source.schemaDefinition, dest.schemaDefinition);
   for (const type of typesToCopy(source, dest)) {
-    copyNamedTypeInner(type, dest.type(type.name)!);
+    copyNamedTypeInner(type, dest.type(type.name)!, cloneJoinDirectives);
   }
 }
 
@@ -3653,7 +3657,7 @@ function copySchemaDefinitionInner(source: SchemaDefinition, dest: SchemaDefinit
   dest.sourceAST = source.sourceAST;
 }
 
-function copyNamedTypeInner(source: NamedType, dest: NamedType) {
+function copyNamedTypeInner(source: NamedType, dest: NamedType, cloneJoinDirectives: boolean) {
   dest.preserveEmptyDefinition = source.preserveEmptyDefinition;
   const extensionsMap = copyExtensions(source, dest);
   // Same as copyAppliedDirectives, but as the directive applies to the type, we need to remember if the application
@@ -3670,7 +3674,7 @@ function copyNamedTypeInner(source: NamedType, dest: NamedType) {
       for (const sourceField of source.fields()) {
         const destField = destFieldBasedType.addField(new FieldDefinition(sourceField.name));
         copyOfExtension(extensionsMap, sourceField, destField);
-        copyFieldDefinitionInner(sourceField, destField);
+        copyFieldDefinitionInner(sourceField, destField, cloneJoinDirectives);
       }
       for (const sourceImpl of source.interfaceImplementations()) {
         const destImpl = destFieldBasedType.addImplementedInterface(sourceImpl.interface.name);
@@ -3690,7 +3694,7 @@ function copyNamedTypeInner(source: NamedType, dest: NamedType) {
         const destValue = destEnumType.addValue(sourceValue.name);
         destValue.description = sourceValue.description;
         copyOfExtension(extensionsMap, sourceValue, destValue);
-        copyAppliedDirectives(sourceValue, destValue);
+        copyAppliedDirectives(sourceValue, destValue, cloneJoinDirectives);
       }
       break
     case 'InputObjectType':
@@ -3698,13 +3702,13 @@ function copyNamedTypeInner(source: NamedType, dest: NamedType) {
       for (const sourceField of source.fields()) {
         const destField = destInputType.addField(new InputFieldDefinition(sourceField.name));
         copyOfExtension(extensionsMap, sourceField, destField);
-        copyInputFieldDefinitionInner(sourceField, destField);
+        copyInputFieldDefinitionInner(sourceField, destField, cloneJoinDirectives);
       }
   }
 }
 
-function copyAppliedDirectives(source: SchemaElement<any, any>, dest: SchemaElement<any, any>) {
-  source.appliedDirectives.forEach((d) => copyAppliedDirective(d, dest));
+function copyAppliedDirectives(source: SchemaElement<any, any>, dest: SchemaElement<any, any>, cloneJoinDirectives: boolean) {
+  source.appliedDirectives.filter(d => cloneJoinDirectives || !d.name.startsWith('join__')).forEach((d) => copyAppliedDirective(d, dest));
 }
 
 function copyAppliedDirective(source: Directive<any, any>, dest: SchemaElement<any, any>): Directive<any, any> {
@@ -3713,23 +3717,27 @@ function copyAppliedDirective(source: Directive<any, any>, dest: SchemaElement<a
   return res;
 }
 
-function copyFieldDefinitionInner<P extends ObjectType | InterfaceType>(source: FieldDefinition<P>, dest: FieldDefinition<P>) {
+function copyFieldDefinitionInner<P extends ObjectType | InterfaceType>(source: FieldDefinition<P>, dest: FieldDefinition<P>, cloneJoinDirectives: boolean) {
   const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as OutputType;
   dest.type = type;
   for (const arg of source.arguments()) {
     const argType = copyWrapperTypeOrTypeRef(arg.type, dest.schema());
-    copyArgumentDefinitionInner(arg, dest.addArgument(arg.name, argType as InputType));
+    copyArgumentDefinitionInner({
+      source: arg, 
+      dest: dest.addArgument(arg.name, argType as InputType),
+      cloneJoinDirectives,
+    });
   }
-  copyAppliedDirectives(source, dest);
+  copyAppliedDirectives(source, dest, cloneJoinDirectives);
   dest.description = source.description;
   dest.sourceAST = source.sourceAST;
 }
 
-function copyInputFieldDefinitionInner(source: InputFieldDefinition, dest: InputFieldDefinition) {
+function copyInputFieldDefinitionInner(source: InputFieldDefinition, dest: InputFieldDefinition, cloneJoinDirectives: boolean) {
   const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as InputType;
   dest.type = type;
   dest.defaultValue = source.defaultValue;
-  copyAppliedDirectives(source, dest);
+  copyAppliedDirectives(source, dest, cloneJoinDirectives);
   dest.description = source.description;
   dest.sourceAST = source.sourceAST;
 }
@@ -3748,16 +3756,22 @@ function copyWrapperTypeOrTypeRef(source: Type | undefined, destParent: Schema):
   }
 }
 
-function copyArgumentDefinitionInner<P extends FieldDefinition<any> | DirectiveDefinition>(
+function copyArgumentDefinitionInner<P extends FieldDefinition<any> | DirectiveDefinition>({
+  source,
+  dest,
+  copyDirectiveApplications = true,
+  cloneJoinDirectives,
+}: {
   source: ArgumentDefinition<P>,
   dest: ArgumentDefinition<P>,
-  copyDirectiveApplications: boolean = true,
-) {
+  copyDirectiveApplications?: boolean,
+  cloneJoinDirectives: boolean,
+}) {
   const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as InputType;
   dest.type = type;
   dest.defaultValue = source.defaultValue;
   if (copyDirectiveApplications) {
-    copyAppliedDirectives(source, dest);
+    copyAppliedDirectives(source, dest, cloneJoinDirectives);
   }
   dest.description = source.description;
   dest.sourceAST = source.sourceAST;
@@ -3779,7 +3793,12 @@ function copyDirectiveDefinitionInner(
 
   for (const arg of source.arguments()) {
     const type = copyWrapperTypeOrTypeRef(arg.type, dest.schema());
-    copyArgumentDefinitionInner(arg, dest.addArgument(arg.name, type as InputType), copyDirectiveApplicationsInArguments);
+    copyArgumentDefinitionInner({
+      source: arg,
+      dest: dest.addArgument(arg.name, type as InputType),
+      copyDirectiveApplications: copyDirectiveApplicationsInArguments,
+      cloneJoinDirectives: true,
+    });
   }
   dest.repeatable = source.repeatable;
   dest.addLocations(...locations);

package/src/federation.ts

@@ -1195,7 +1195,7 @@ export class FederationMetadata {
   ): Post20FederationDirectiveDefinition<TApplicationArgs> {
     return this.getFederationDirective<TApplicationArgs>(name) ?? {
       name,
-      applications: () => new Array<Directive<any, TApplicationArgs>>(),
+      applications: () => new Set<Directive<any, TApplicationArgs>>(),
     };
   }
 
@@ -1391,7 +1391,7 @@ export class FederationMetadata {
 
 export type FederationDirectiveNotDefinedInSchema<TApplicationArgs extends {[key: string]: any}> = {
   name: string,
-  applications: () => readonly Directive<any, TApplicationArgs>[],
+  applications: () => ReadonlySet<Directive<any, TApplicationArgs>>,
 }
 
 export type Post20FederationDirectiveDefinition<TApplicationArgs extends {[key: string]: any}> =
@@ -1577,12 +1577,19 @@ export class FederationBlueprint extends SchemaBlueprint {
       const parent = application.parent;
       const name = application.arguments().name as string;
       
+      const match = name.match(/^([A-Za-z]\w*)$/);
       if (name.includes('_')) {
         errorCollector.push(ERRORS.CONTEXT_NAME_INVALID.err(
           `Context name "${name}" may not contain an underscore.`,
           { nodes: sourceASTs(application) }
         ));
       }
+      else if (!match) {
+        errorCollector.push(ERRORS.CONTEXT_NAME_INVALID.err(
+          `Context name "${name}" is invalid. It should have only alphanumeric characters.`,
+          { nodes: sourceASTs(application) }
+        ));
+      }
       const types = contextToTypeMap.get(name);
       if (types) {
         types.push(parent);
@@ -2033,7 +2040,7 @@ function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
     // definition to re-add the "correct" version, we'd have to re-attach existing applications (doable but not
     // done). This assert is so we notice it quickly if that ever happens (again, unlikely, because fed1 schema
     // is a backward compatibility thing and there is no reason to expand that too much in the future).
-    assert(directive.applications().length === 0, `${directive} shouldn't have had validation at that places`);
+    assert(directive.applications().size === 0, `${directive} shouldn't have had validation at that places`);
 
     // The patterns we recognize and "correct" (by essentially ignoring the definition)
     // are:

package/src/operations.ts

@@ -1594,16 +1594,17 @@ export class SelectionSet {
         // No match, so we need to create a new fragment. First, we minimize the
         // selection set before creating the fragment with it.
         const [minimizedSelectionSet] = selection.selectionSet.minimizeSelectionSet(namedFragments, seenSelections);
+        const updatedEquivalentSelectionSetCandidates = seenSelections.get(mockHashCode); // may have changed after previous statement
         const fragmentDefinition = new NamedFragmentDefinition(
           this.parentType.schema(),
-          `_generated_${mockHashCode}_${equivalentSelectionSetCandidates?.length ?? 0}`,
+          `_generated_${mockHashCode}_${updatedEquivalentSelectionSetCandidates?.length ?? 0}`,
           selection.element.typeCondition
         ).setSelectionSet(minimizedSelectionSet);
         namedFragments.add(fragmentDefinition);
 
         // Create a new "hash code" bucket or add to the existing one.
-        if (equivalentSelectionSetCandidates) {
-          equivalentSelectionSetCandidates.push([selection.selectionSet, fragmentDefinition]);
+        if (updatedEquivalentSelectionSetCandidates) {
+          updatedEquivalentSelectionSetCandidates.push([selection.selectionSet, fragmentDefinition]);
         } else {
             seenSelections.set(mockHashCode, [[selection.selectionSet, fragmentDefinition]]);
         }

package/src/schemaUpgrader.ts

@@ -233,7 +233,7 @@ export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
   for (const subgraph of inputs.values()) {
     if (subgraph.isFed2Subgraph()) {
       subgraphs.add(subgraph);
-      if (subgraph.metadata().interfaceObjectDirective().applications().length > 0) {
+      if (subgraph.metadata().interfaceObjectDirective().applications().size > 0) {
         subgraphsUsingInterfaceObject.push(subgraph.name);
       }
     } else {