@apollo/federation-internals 2.9.0 → 2.9.2

package/src/operations.ts

@@ -69,7 +69,7 @@ function haveSameDirectives<TElement extends OperationElement>(op1: TElement, op
 }
 
 abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> extends DirectiveTargetElement<T> {
-  private attachements?: Map<string, string>;
+  private attachments?: Map<string, string>;
 
   constructor(
     schema: Schema,
@@ -97,21 +97,21 @@ abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> e
 
   protected abstract collectVariablesInElement(collector: VariableCollector): void;
 
-  addAttachement(key: string, value: string) {
-    if (!this.attachements) {
-      this.attachements = new Map();
+  addAttachment(key: string, value: string) {
+    if (!this.attachments) {
+      this.attachments = new Map();
     }
-    this.attachements.set(key, value);
+    this.attachments.set(key, value);
   }
 
-  getAttachement(key: string): string | undefined {
-    return this.attachements?.get(key);
+  getAttachment(key: string): string | undefined {
+    return this.attachments?.get(key);
   }
 
-  protected copyAttachementsTo(elt: AbstractOperationElement<any>) {
-    if (this.attachements) {
-      for (const [k, v] of this.attachements.entries()) {
-        elt.addAttachement(k, v);
+  protected copyAttachmentsTo(elt: AbstractOperationElement<any>) {
+    if (this.attachments) {
+      for (const [k, v] of this.attachments.entries()) {
+        elt.addAttachment(k, v);
       }
     }
   }
@@ -170,6 +170,17 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
   baseType(): NamedType {
     return baseType(this.definition.type!);
   }
+
+  copy(): Field<TArgs> {
+    const newField = new Field<TArgs>(
+      this.definition,
+      this.args,
+      this.appliedDirectives,
+      this.alias,
+    );
+    this.copyAttachmentsTo(newField);
+    return newField;
+  }
   
   withUpdatedArguments(newArgs: TArgs): Field<TArgs> {
     const newField = new Field<TArgs>(
@@ -178,7 +189,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -189,7 +200,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -200,7 +211,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       this.appliedDirectives,
       newAlias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -211,7 +222,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       newDirectives,
       this.alias,
     );
-    this.copyAttachementsTo(newField);
+    this.copyAttachmentsTo(newField);
     return newField;
   }
 
@@ -505,13 +516,13 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     // schema (typically, the supergraph) than `this.sourceType` (typically, a subgraph), then the new condition uses the
     // definition of the proper schema (the supergraph in such cases, instead of the subgraph).
     const newFragment = new FragmentElement(newSourceType, newCondition?.name, this.appliedDirectives);
-    this.copyAttachementsTo(newFragment);
+    this.copyAttachmentsTo(newFragment);
     return newFragment;
   }
 
   withUpdatedDirectives(newDirectives: Directive<OperationElement>[]): FragmentElement {
     const newFragment = new FragmentElement(this.sourceType, this.typeCondition, newDirectives);
-    this.copyAttachementsTo(newFragment);
+    this.copyAttachmentsTo(newFragment);
     return newFragment;
   }
 
@@ -590,7 +601,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     }
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
-    this.copyAttachementsTo(updated);
+    this.copyAttachmentsTo(updated);
     return updated;
   }
 
@@ -655,7 +666,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
       .concat(new Directive<FragmentElement>(deferDirective.name, newDeferArgs));
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
-    this.copyAttachementsTo(updated);
+    this.copyAttachmentsTo(updated);
     return updated;
   }
 
@@ -3042,6 +3053,12 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this.element.definition.name === typenameFieldName;
   }
 
+  withAttachment(key: string, value: string): FieldSelection {
+    const updatedField = this.element.copy();
+    updatedField.addAttachment(key, value);
+    return this.withUpdatedElement(updatedField);
+  }
+
   withUpdatedComponents(field: Field<any>, selectionSet: SelectionSet | undefined): FieldSelection {
     if (this.element === field && this.selectionSet === selectionSet) {
       return this;

package/src/specs/coreSpec.ts

@@ -195,7 +195,8 @@ export type CoreDirectiveArgs = {
   url: undefined,
   feature: string,
   as?: string,
-  for?: string
+  for?: string,
+  import: undefined,
 }
 
 export type LinkDirectiveArgs = {
@@ -203,7 +204,7 @@ export type LinkDirectiveArgs = {
   feature: undefined,
   as?: string,
   for?: string,
-  import?: (string | CoreImport)[]
+  import?: (string | CoreImport)[],
 }
 
 export type CoreOrLinkDirectiveArgs = CoreDirectiveArgs | LinkDirectiveArgs;
@@ -539,36 +540,36 @@ export class CoreSpecDefinition extends FeatureDefinition {
     return feature.url.version;
   }
 
-  applyFeatureToSchema(schema: Schema, feature: FeatureDefinition, as?: string, purpose?: CorePurpose): GraphQLError[] {
+  applyFeatureToSchema(
+    schema: Schema,
+    feature: FeatureDefinition,
+    as?: string,
+    purpose?: CorePurpose,
+    imports?: CoreImport[],
+  ): GraphQLError[] {
     const coreDirective = this.coreDirective(schema);
     const args = {
       [this.urlArgName()]: feature.toString(),
       as,
-    } as CoreDirectiveArgs;
-    if (this.supportPurposes() && purpose) {
-      args.for = purpose;
-    }
-    schema.schemaDefinition.applyDirective(coreDirective, args);
-    return feature.addElementsToSchema(schema);
-  }
-
-  applyFeatureAsLink(schema: Schema, feature: FeatureDefinition, purpose?: CorePurpose, imports?: CoreImport[]): GraphQLError[] {
-    const existing = schema.schemaDefinition.appliedDirectivesOf(linkDirectiveDefaultName).find((link) => link.arguments().url === feature.toString());
-    if (existing) {
-      existing.remove();
+    } as CoreOrLinkDirectiveArgs;
+    if (purpose) {
+      if (this.supportPurposes()) {
+        args.for = purpose;
+      } else {
+        return [new GraphQLError(
+          `Cannot apply feature ${feature} with purpose since the schema's @core/@link version does not support it.`
+        )];
+      }
     }
-
-    const coreDirective = this.coreDirective(schema);
-    const args: LinkDirectiveArgs = {
-      url: feature.toString(),
-      import: (existing?.arguments().import ?? []).concat(imports?.map((i) => i.as ? { name: `@${i.name}`, as: `@${i.as}` } : `@${i.name}`)),
-      feature: undefined,
-    };
-
-    if (this.supportPurposes() && purpose) {
-      args.for = purpose;
+    if (imports && imports.length > 0) {
+      if (this.supportImport()) {
+        args.import = imports.map(i => i.as ? i : i.name);
+      } else {
+        return [new GraphQLError(
+          `Cannot apply feature ${feature} with imports since the schema's @core/@link version does not support it.`
+        )];
+      }
     }
-
     schema.schemaDefinition.applyDirective(coreDirective, args);
     return feature.addElementsToSchema(schema);
   }

package/src/specs/costSpec.ts

@@ -1,7 +1,7 @@
 import { DirectiveLocation } from 'graphql';
 import { createDirectiveSpecification } from '../directiveAndTypeSpecification';
 import { FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from './coreSpec';
-import { ListType, NonNullType } from '../definitions';
+import { DirectiveDefinition, ListType, NonNullType, Schema } from '../definitions';
 import { registerKnownFeature } from '../knownCoreFeatures';
 import { ARGUMENT_COMPOSITION_STRATEGIES } from '../argumentCompositionStrategies';
 
@@ -41,6 +41,14 @@ export class CostSpecDefinition extends FeatureDefinition {
       supergraphSpecification: (fedVersion) => COST_VERSIONS.getMinimumRequiredVersion(fedVersion)
     }));
   }
+
+  costDirective(schema: Schema): DirectiveDefinition<CostDirectiveArguments> | undefined {
+    return this.directive(schema, 'cost');
+  }
+
+  listSizeDirective(schema: Schema): DirectiveDefinition<ListSizeDirectiveArguments> | undefined {
+    return this.directive(schema, 'listSize');
+  }
 }
 
 export const COST_VERSIONS = new FeatureDefinitions<CostSpecDefinition>(costIdentity)

package/src/supergraphs.ts

@@ -1,7 +1,9 @@
 import { DocumentNode, GraphQLError } from "graphql";
-import { ErrCoreCheckFailed, FeatureUrl, FeatureVersion } from "./specs/coreSpec";
 import { CoreFeatures, Schema, sourceASTs } from "./definitions";
+import { ErrCoreCheckFailed, FeatureUrl, FeatureVersion } from "./specs/coreSpec";
 import { joinIdentity, JoinSpecDefinition, JOIN_VERSIONS } from "./specs/joinSpec";
+import { CONTEXT_VERSIONS, ContextSpecDefinition } from "./specs/contextSpec";
+import { COST_VERSIONS, costIdentity, CostSpecDefinition } from "./specs/costSpec";
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
 import { extractSubgraphsNamesAndUrlsFromSupergraph, extractSubgraphsFromSupergraph } from "./extractSubgraphsFromSupergraph";
 import { ERRORS } from "./error";
@@ -81,11 +83,17 @@ function checkFeatureSupport(coreFeatures: CoreFeatures, supportedFeatures: Set<
   }
 }
 
-export function validateSupergraph(supergraph: Schema): [CoreFeatures, JoinSpecDefinition] {
+export function validateSupergraph(supergraph: Schema): [
+  CoreFeatures,
+  JoinSpecDefinition,
+  ContextSpecDefinition | undefined,
+  CostSpecDefinition | undefined,
+] {
   const coreFeatures = supergraph.coreFeatures;
   if (!coreFeatures) {
     throw ERRORS.INVALID_FEDERATION_SUPERGRAPH.err("Invalid supergraph: must be a core schema");
   }
+
   const joinFeature = coreFeatures.getByIdentity(joinIdentity);
   if (!joinFeature) {
     throw ERRORS.INVALID_FEDERATION_SUPERGRAPH.err("Invalid supergraph: must use the join spec");
@@ -95,7 +103,27 @@ export function validateSupergraph(supergraph: Schema): [CoreFeatures, JoinSpecD
     throw ERRORS.INVALID_FEDERATION_SUPERGRAPH.err(
       `Invalid supergraph: uses unsupported join spec version ${joinFeature.url.version} (supported versions: ${JOIN_VERSIONS.versions().join(', ')})`);
   }
-  return [coreFeatures, joinSpec];
+
+  const contextFeature = coreFeatures.getByIdentity(ContextSpecDefinition.identity);
+  let contextSpec = undefined;
+  if (contextFeature) {
+    contextSpec = CONTEXT_VERSIONS.find(contextFeature.url.version);
+    if (!contextSpec) {
+      throw ERRORS.INVALID_FEDERATION_SUPERGRAPH.err(
+        `Invalid supergraph: uses unsupported context spec version ${contextFeature.url.version} (supported versions: ${CONTEXT_VERSIONS.versions().join(', ')})`);
+    }
+  }
+
+  const costFeature = coreFeatures.getByIdentity(costIdentity);
+  let costSpec = undefined;
+  if (costFeature) {
+    costSpec = COST_VERSIONS.find(costFeature.url.version);
+    if (!costSpec) {
+      throw ERRORS.INVALID_FEDERATION_SUPERGRAPH.err(
+        `Invalid supergraph: uses unsupported cost spec version ${costFeature.url.version} (supported versions: ${COST_VERSIONS.versions().join(', ')})`);
+    }
+  }
+  return [coreFeatures, joinSpec, contextSpec, costSpec];
 }
 
 export function isFed1Supergraph(supergraph: Schema): boolean {

package/src/values.ts

@@ -135,8 +135,10 @@ export function valueEquals(a: any, b: any): boolean {
   if (Array.isArray(a)) {
     return Array.isArray(b) && arrayValueEquals(a, b) ;
   }
-  if (typeof a === 'object') {
-    return typeof b === 'object' && objectEquals(a, b);
+  // Note that typeof null === 'object', so we have to manually rule that out
+  // here.
+  if (a !== null && typeof a === 'object') {
+    return b !== null && typeof b === 'object' && objectEquals(a, b);
   }
   return a === b;
 }
@@ -224,8 +226,10 @@ function applyDefaultValues(value: any, type: InputType): any {
       if (fieldValue === undefined) {
         if (field.defaultValue !== undefined) {
           updated[field.name] = applyDefaultValues(field.defaultValue, field.type);
-        } else if (isNonNullType(field.type)) {
-          throw ERRORS.INVALID_GRAPHQL.err(`Field "${field.name}" of required type ${type} was not provided.`);
+        } else if (!isNonNullType(field.type)) {
+          updated[field.name] = null;
+        } else {
+          throw ERRORS.INVALID_GRAPHQL.err(`Required field "${field.name}" of type ${type} was not provided.`);
         }
       } else {
         updated[field.name] = applyDefaultValues(fieldValue, field.type);
@@ -249,8 +253,12 @@ export function withDefaultValues(value: any, argument: ArgumentDefinition<any>)
     throw buildError(`Cannot compute default value for argument ${argument} as the type is undefined`);
   }
   if (value === undefined) {
-    if (argument.defaultValue) {
+    if (argument.defaultValue !== undefined) {
       return applyDefaultValues(argument.defaultValue, argument.type);
+    } else if (!isNonNullType(argument.type)) {
+      return null;
+    } else {
+      throw ERRORS.INVALID_GRAPHQL.err(`Required argument "${argument.coordinate}" was not provided.`);
     }
   }
   return applyDefaultValues(value, argument.type);