@apollo/federation-internals 2.7.8 → 2.8.0-alpha.0

package/src/operations.ts

@@ -21,11 +21,9 @@ import {
   Directive,
   DirectiveTargetElement,
   FieldDefinition,
-  InterfaceType,
   isCompositeType,
   isInterfaceType,
   isNullableType,
-  ObjectType,
   runtimeTypesIntersects,
   Schema,
   SchemaRootKind,
@@ -51,7 +49,7 @@ import {
   directivesToString,
   directivesToDirectiveNodes,
 } from "./definitions";
-import { isInterfaceObjectType } from "./federation";
+import { federationMetadata, isFederationDirectiveDefinedInSchema, isInterfaceObjectType } from "./federation";
 import { ERRORS } from "./error";
 import { isSubtype, sameType, typesCanBeMerged } from "./types";
 import { assert, mapKeys, mapValues, MapWithCachedArrays, MultiMap, SetMultiMap } from "./utils";
@@ -170,6 +168,17 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
   baseType(): NamedType {
     return baseType(this.definition.type!);
   }
+  
+  withUpdatedArguments(newArgs: TArgs): Field<TArgs> {
+    const newField = new Field<TArgs>(
+      this.definition,
+      { ...this.args, ...newArgs },
+      this.appliedDirectives,
+      this.alias,
+    );
+    this.copyAttachementsTo(newField);
+    return newField;
+  }
 
   withUpdatedDefinition(newDefinition: FieldDefinition<any>): Field<TArgs> {
     const newField = new Field<TArgs>(
@@ -222,17 +231,12 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       };
     });
   }
-
-
-  appliesTo(type: ObjectType | InterfaceType): boolean {
-    const definition = type.field(this.name);
-    return !!definition && this.selects(definition);
-  }
-
+  
   selects(
     definition: FieldDefinition<any>,
     assumeValid: boolean = false,
     variableDefinitions?: VariableDefinitions,
+    contextualArguments?: string[],
   ): boolean {
     assert(assumeValid || variableDefinitions, 'Must provide variable definitions if validation is needed');
 
@@ -252,7 +256,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     for (const argDef of definition.arguments()) {
       const appliedValue = this.argumentValue(argDef.name);
       if (appliedValue === undefined) {
-        if (argDef.defaultValue === undefined && !isNullableType(argDef.type!)) {
+        if (argDef.defaultValue === undefined && !isNullableType(argDef.type!) && (!contextualArguments || !contextualArguments?.includes(argDef.name))) {
           return false;
         }
       } else {
@@ -273,19 +277,28 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     return true;
   }
 
-  validate(variableDefinitions: VariableDefinitions) {
+  validate(variableDefinitions: VariableDefinitions, validateContextualArgs: boolean) {
     validate(this.name === this.definition.name, () => `Field name "${this.name}" cannot select field "${this.definition.coordinate}: name mismatch"`);
-
+    
+    
     // We need to make sure the field has valid values for every non-optional argument.
     for (const argDef of this.definition.arguments()) {
       const appliedValue = this.argumentValue(argDef.name);
+
+      let isContextualArg = false;
+      const schema = this.definition.schema();
+      const fromContextDirective = federationMetadata(schema)?.fromContextDirective();
+      if (fromContextDirective && isFederationDirectiveDefinedInSchema(fromContextDirective)) {
+        isContextualArg = argDef.appliedDirectivesOf(fromContextDirective).length > 0;
+      }
+
       if (appliedValue === undefined) {
         validate(
-          argDef.defaultValue !== undefined || isNullableType(argDef.type!),
+          (isContextualArg && !validateContextualArgs) || argDef.defaultValue !== undefined || isNullableType(argDef.type!),
           () => `Missing mandatory value for argument "${argDef.name}" of field "${this.definition.coordinate}" in selection "${this}"`);
       } else {
         validate(
-          isValidValue(appliedValue, argDef, variableDefinitions),
+          (isContextualArg && !validateContextualArgs) || isValidValue(appliedValue, argDef, variableDefinitions),
           () => `Invalid value ${valueToString(appliedValue)} for argument "${argDef.coordinate}" of type ${argDef.type}`)
       }
     }
@@ -1998,10 +2011,10 @@ export class SelectionSet {
     return this.selections().every((selection) => selection.canAddTo(parentTypeToTest));
   }
 
-  validate(variableDefinitions: VariableDefinitions) {
+  validate(variableDefinitions: VariableDefinitions, validateContextualArgs: boolean = false) {
     validate(!this.isEmpty(), () => `Invalid empty selection set`);
     for (const selection of this.selections()) {
-      selection.validate(variableDefinitions);
+      selection.validate(variableDefinitions, validateContextualArgs);
     }
   }
 
@@ -2520,7 +2533,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   abstract toSelectionNode(): SelectionNode;
 
-  abstract validate(variableDefinitions: VariableDefinitions): void;
+  abstract validate(variableDefinitions: VariableDefinitions, validateContextualArgs: boolean): void;
 
   abstract rebaseOn(args: { parentType: CompositeType, fragments: NamedFragments | undefined, errorIfCannotRebase: boolean}): TOwnType | undefined;
 
@@ -3035,8 +3048,8 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
   }
 
-  validate(variableDefinitions: VariableDefinitions) {
-    this.element.validate(variableDefinitions);
+  validate(variableDefinitions: VariableDefinitions, validateContextualArgs: boolean) {
+    this.element.validate(variableDefinitions, validateContextualArgs);
     // Note that validation is kind of redundant since `this.selectionSet.validate()` will check that it isn't empty. But doing it
     // allow to provide much better error messages.
     validate(
@@ -3955,7 +3968,7 @@ export function parseSelectionSet({
   return selectionSet;
 }
 
-function parseOperationAST(source: string): OperationDefinitionNode {
+export function parseOperationAST(source: string): OperationDefinitionNode {
   const parsed = parse(source);
   validate(parsed.definitions.length === 1, () => 'Selections should contain a single definitions, found ' + parsed.definitions.length);
   const def = parsed.definitions[0];
@@ -3980,3 +3993,17 @@ export function operationToDocument(operation: Operation): DocumentNode {
     definitions: [operationAST as DefinitionNode].concat(fragmentASTs),
   };
 }
+
+export function hasSelectionWithPredicate(selectionSet: SelectionSet, predicate: (s: Selection) => boolean): boolean {
+  for (const selection of selectionSet.selections()) {
+    if (predicate(selection)) {
+      return true;
+    }
+    if (selection.selectionSet) {
+      if (hasSelectionWithPredicate(selection.selectionSet, predicate)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/specs/contextSpec.ts

@@ -0,0 +1,87 @@
+import { DirectiveLocation } from "graphql";
+import {
+  CorePurpose,
+  FeatureDefinition,
+  FeatureDefinitions,
+  FeatureUrl,
+  FeatureVersion,
+} from "./coreSpec";
+import { DirectiveDefinition, NonNullType, Schema, isInputType } from "../definitions";
+import { DirectiveSpecification, createDirectiveSpecification, createScalarTypeSpecification } from "../directiveAndTypeSpecification";
+import { registerKnownFeature } from "../knownCoreFeatures";
+import { Subgraph } from '../federation';
+import { assert } from '../utils';
+
+export enum ContextDirectiveName {
+  CONTEXT = 'context',
+  FROM_CONTEXT = 'fromContext',
+}
+
+const fieldValueScalar = 'ContextFieldValue';
+
+export class ContextSpecDefinition extends FeatureDefinition {
+  public static readonly directiveName = 'context';
+  public static readonly identity =
+    `https://specs.apollo.dev/${ContextSpecDefinition.directiveName}`;
+  public readonly contextDirectiveSpec: DirectiveSpecification;
+  public readonly fromContextDirectiveSpec: DirectiveSpecification;
+
+  constructor(version: FeatureVersion) {
+    super(
+      new FeatureUrl(
+        ContextSpecDefinition.identity,
+        ContextSpecDefinition.directiveName,
+        version,
+      )
+    );
+
+    this.registerType(createScalarTypeSpecification({ name: fieldValueScalar }));
+    
+    this.contextDirectiveSpec = createDirectiveSpecification({
+      name: ContextDirectiveName.CONTEXT,
+      locations: [DirectiveLocation.INTERFACE, DirectiveLocation.OBJECT, DirectiveLocation.UNION],
+      args: [{ name: 'name', type: (schema) => new NonNullType(schema.stringType())}],
+      composes: true,
+      repeatable: true,
+      supergraphSpecification: (fedVersion) => CONTEXT_VERSIONS.getMinimumRequiredVersion(fedVersion),
+      staticArgumentTransform: (subgraph: Subgraph, args: {[key: string]: any}) => {
+        const subgraphName = subgraph.name;
+        return {
+          name: `${subgraphName}__${args.name}`,
+        }; 
+      },
+    });
+    
+    this.fromContextDirectiveSpec = createDirectiveSpecification({
+      name: ContextDirectiveName.FROM_CONTEXT,
+      locations: [DirectiveLocation.ARGUMENT_DEFINITION],
+      args: [{ name: 'field', type: (schema, feature) => {
+        assert(feature, "Shouldn't be added without being attached to a @link spec");
+        const fieldValue = feature.typeNameInSchema(fieldValueScalar);
+        const fieldValueType = schema.type(fieldValue);
+        assert(fieldValueType, () => `Expected "${fieldValue}" to be defined`);
+        assert(isInputType(fieldValueType), `Expected "${fieldValue}" to be an input type`);
+        return fieldValueType;
+      }}],
+      composes: false,
+    });
+    
+    this.registerDirective(this.contextDirectiveSpec);
+    this.registerDirective(this.fromContextDirectiveSpec);
+  }
+
+  get defaultCorePurpose(): CorePurpose {
+    return 'SECURITY';
+  }
+  
+  contextDirective(schema: Schema): DirectiveDefinition<{ name: string }> | undefined {
+    return this.directive(schema, ContextSpecDefinition.directiveName);
+  }
+}
+
+export const CONTEXT_VERSIONS =
+  new FeatureDefinitions<ContextSpecDefinition>(
+    ContextSpecDefinition.identity
+  ).add(new ContextSpecDefinition(new FeatureVersion(0, 1)));
+
+registerKnownFeature(CONTEXT_VERSIONS);

package/src/specs/federationSpec.ts

@@ -19,11 +19,13 @@ import { AUTHENTICATED_VERSIONS } from "./authenticatedSpec";
 import { REQUIRES_SCOPES_VERSIONS } from "./requiresScopesSpec";
 import { POLICY_VERSIONS } from './policySpec';
 import { SOURCE_VERSIONS } from './sourceSpec';
+import { CONTEXT_VERSIONS } from './contextSpec';
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
 export enum FederationTypeName {
   FIELD_SET = 'FieldSet',
+  CONTEXT_FIELD_VALUE = 'ContextFieldValue',
 }
 
 export enum FederationDirectiveName {
@@ -44,6 +46,8 @@ export enum FederationDirectiveName {
   SOURCE_API = 'sourceAPI',
   SOURCE_TYPE = 'sourceType',
   SOURCE_FIELD = 'sourceField',
+  CONTEXT = 'context',
+  FROM_CONTEXT = 'fromContext',
 }
 
 const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
@@ -174,6 +178,10 @@ export class FederationSpecDefinition extends FeatureDefinition {
     if (version.gte(new FeatureVersion(2, 7))) {
       this.registerSubFeature(SOURCE_VERSIONS.find(new FeatureVersion(0, 1))!);
     }
+    
+    if (version.gte(new FeatureVersion(2, 8))) {
+      this.registerSubFeature(CONTEXT_VERSIONS.find(new FeatureVersion(0, 1))!);
+    }
   }
 }
 
@@ -185,6 +193,7 @@ export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefiniti
   .add(new FederationSpecDefinition(new FeatureVersion(2, 4)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 5)))
   .add(new FederationSpecDefinition(new FeatureVersion(2, 6)))
-  .add(new FederationSpecDefinition(new FeatureVersion(2, 7)));
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 7)))
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 8)));
 
 registerKnownFeature(FEDERATION_VERSIONS);

package/src/specs/joinSpec.ts

@@ -7,6 +7,7 @@ import {
   Schema,
   NonNullType,
   ListType,
+  InputObjectType,
 } from "../definitions";
 import { Subgraph, Subgraphs } from "../federation";
 import { registerKnownFeature } from '../knownCoreFeatures';
@@ -36,7 +37,7 @@ export type JoinTypeDirectiveArguments = {
   key?: string,
   extension?: boolean,
   resolvable?: boolean,
-  isInterfaceObject?: boolean
+  isInterfaceObject?: boolean,
 };
 
 export type JoinFieldDirectiveArguments = {
@@ -48,6 +49,12 @@ export type JoinFieldDirectiveArguments = {
   external?: boolean,
   usedOverridden?: boolean,
   overrideLabel?: string,
+  contextArguments?: {
+    name: string,
+    type: string,
+    context: string,
+    selection: string,
+  }[],
 }
 
 export type JoinDirectiveArguments = {
@@ -151,9 +158,24 @@ export class JoinSpecDefinition extends FeatureDefinition {
       joinDirective.addArgument('name', new NonNullType(schema.stringType()));
       joinDirective.addArgument('args', this.addScalarType(schema, 'DirectiveArguments'));
 
-      //progressive override
+      // progressive override
       joinField.addArgument('overrideLabel', schema.stringType());
     }
+    
+    if (this.version.gte(new FeatureVersion(0, 5))) {
+      const fieldValue = this.addScalarType(schema, 'FieldValue');
+
+      // set context
+      // there are no renames that happen within the join spec, so this is fine
+      // note that join spec will only used in supergraph schema
+      const contextArgumentsType = schema.addType(new InputObjectType('join__ContextArgument'));
+      contextArgumentsType.addField('name', new NonNullType(schema.stringType()));
+      contextArgumentsType.addField('type', new NonNullType(schema.stringType()));
+      contextArgumentsType.addField('context', new NonNullType(schema.stringType()));
+      contextArgumentsType.addField('selection', new NonNullType(fieldValue));
+
+      joinField.addArgument('contextArguments', new ListType(new NonNullType(contextArgumentsType)));
+    }
 
     if (this.isV01()) {
       const joinOwner = this.addDirective(schema, 'owner').addLocations(DirectiveLocation.OBJECT);
@@ -261,10 +283,12 @@ export class JoinSpecDefinition extends FeatureDefinition {
 //  - 0.2: this is the original version released with federation 2.
 //  - 0.3: adds the `isInterfaceObject` argument to `@join__type`, and make the `graph` in `@join__field` skippable.
 //  - 0.4: adds the optional `overrideLabel` argument to `@join_field` for progressive override.
+//  - 0.5: adds the `contextArguments` argument to `@join_field` for setting context.
 export const JOIN_VERSIONS = new FeatureDefinitions<JoinSpecDefinition>(joinIdentity)
   .add(new JoinSpecDefinition(new FeatureVersion(0, 1)))
   .add(new JoinSpecDefinition(new FeatureVersion(0, 2)))
   .add(new JoinSpecDefinition(new FeatureVersion(0, 3), new FeatureVersion(2, 0)))
-  .add(new JoinSpecDefinition(new FeatureVersion(0, 4), new FeatureVersion(2, 7)));
+  .add(new JoinSpecDefinition(new FeatureVersion(0, 4), new FeatureVersion(2, 7)))
+  .add(new JoinSpecDefinition(new FeatureVersion(0, 5), new FeatureVersion(2, 8)));
 
 registerKnownFeature(JOIN_VERSIONS);

package/src/supergraphs.ts

@@ -14,6 +14,7 @@ export const DEFAULT_SUPPORTED_SUPERGRAPH_FEATURES = new Set([
   'https://specs.apollo.dev/join/v0.2',
   'https://specs.apollo.dev/join/v0.3',
   'https://specs.apollo.dev/join/v0.4',
+  'https://specs.apollo.dev/join/v0.5',
   'https://specs.apollo.dev/tag/v0.1',
   'https://specs.apollo.dev/tag/v0.2',
   'https://specs.apollo.dev/tag/v0.3',
@@ -21,6 +22,26 @@ export const DEFAULT_SUPPORTED_SUPERGRAPH_FEATURES = new Set([
   'https://specs.apollo.dev/inaccessible/v0.2',
 ]);
 
+export const ROUTER_SUPPORTED_SUPERGRAPH_FEATURES = new Set([
+  'https://specs.apollo.dev/core/v0.1',
+  'https://specs.apollo.dev/core/v0.2',
+  'https://specs.apollo.dev/join/v0.1',
+  'https://specs.apollo.dev/join/v0.2',
+  'https://specs.apollo.dev/join/v0.3',
+  'https://specs.apollo.dev/join/v0.4',
+  'https://specs.apollo.dev/join/v0.5',
+  'https://specs.apollo.dev/tag/v0.1',
+  'https://specs.apollo.dev/tag/v0.2',
+  'https://specs.apollo.dev/tag/v0.3',
+  'https://specs.apollo.dev/inaccessible/v0.1',
+  'https://specs.apollo.dev/inaccessible/v0.2',
+  'https://specs.apollo.dev/authenticated/v0.1',
+  'https://specs.apollo.dev/requiresScopes/v0.1',
+  'https://specs.apollo.dev/policy/v0.1',
+  'https://specs.apollo.dev/source/v0.1',
+  'https://specs.apollo.dev/context/v0.1',
+]);
+
 const coreVersionZeroDotOneUrl = FeatureUrl.parse('https://specs.apollo.dev/core/v0.1');
 
 /**
@@ -84,6 +105,7 @@ export class Supergraph {
   private readonly containedSubgraphs: readonly {name: string, url: string}[];
   // Lazily computed as that requires a bit of work.
   private _subgraphs?: Subgraphs;
+  private _subgraphNameToGraphEnumValue?: Map<string, string>;
 
   constructor(
     readonly schema: Schema,
@@ -114,6 +136,9 @@ export class Supergraph {
     return new Supergraph(schema, options?.supportedFeatures, options?.validateSupergraph);
   }
 
+  static buildForTests(supergraphSdl: string | DocumentNode, validateSupergraph?: boolean) {
+    return Supergraph.build(supergraphSdl, { supportedFeatures: ROUTER_SUPPORTED_SUPERGRAPH_FEATURES, validateSupergraph });
+  }
   /**
    * The list of names/urls of the subgraphs contained in this subgraph.
    *
@@ -129,11 +154,22 @@ export class Supergraph {
       // Note that `extractSubgraphsFromSupergraph` redo a little bit of work we're already one, like validating
       // the supergraph. We could refactor things to avoid it, but it's completely negligible in practice so we
       // can leave that to "some day, maybe".
-      this._subgraphs = extractSubgraphsFromSupergraph(this.schema, this.shouldValidate);
+      const extractionResults = extractSubgraphsFromSupergraph(this.schema, this.shouldValidate);
+      this._subgraphs = extractionResults[0];
+      this._subgraphNameToGraphEnumValue = extractionResults[1];
     }
     return this._subgraphs;
   }
 
+  subgraphNameToGraphEnumValue(): Map<string, string> {
+    if (!this._subgraphNameToGraphEnumValue) {
+      const extractionResults = extractSubgraphsFromSupergraph(this.schema, this.shouldValidate);
+      this._subgraphs = extractionResults[0];
+      this._subgraphNameToGraphEnumValue = extractionResults[1];
+    }
+    return new Map([...this._subgraphNameToGraphEnumValue]);
+  }
+
   apiSchema(): Schema {
     return this.schema.toAPISchema();
   }

package/src/utils.ts

@@ -441,3 +441,41 @@ export function findLast<T>(array: T[], predicate: (t: T) => boolean): T | undef
   }
   return undefined;
 }
+
+export function mergeMapOrNull<K,V>(m1: Map<K, V> | null, m2: Map<K, V> | null): Map<K, V> | null {
+  if (!m1) {
+    return m2;
+  }
+  if (!m2) {
+    return m1;
+  }
+  return new Map<K, V>([...m1, ...m2]);
+}
+
+export function composeSets<T>(s1: Set<T> | null, s2: Set<T> | null): Set<T> | null {
+  if (!s1 && !s2) {
+    return null;
+  }
+  const result = new Set<T>();
+  s1?.forEach(v => result.add(v));
+  s2?.forEach(v => result.add(v));
+  return result;
+}
+
+export function setsEqual<T>(s1: Set<T> | null, s2: Set<T> | null): boolean {
+  if (s1 === s2) {
+    return true;
+  }
+  if (!s1 && !s2) {
+    return true;
+  }
+  if (!s1 || !s2 || s1.size !== s2.size) {
+    return false;
+  }
+  for (const key of s1) {
+    if (!s2.has(key)) {
+      return false;
+    }
+  }
+  return true;
+}