@apollo/federation-internals 2.8.0-connectors.5 → 2.8.0

package/src/index.ts

@@ -12,6 +12,7 @@ export * from './specs/joinSpec';
 export * from './specs/tagSpec';
 export * from './specs/inaccessibleSpec';
 export * from './specs/federationSpec';
+export * from './specs/contextSpec';
 export * from './supergraphs';
 export * from './error';
 export * from './schemaUpgrader';
@@ -23,4 +24,4 @@ export * from './argumentCompositionStrategies';
 export * from './specs/authenticatedSpec';
 export * from './specs/requiresScopesSpec';
 export * from './specs/policySpec';
-export * from './specs/connectSpec';
+export * from './specs/sourceSpec';

package/src/knownCoreFeatures.ts

@@ -1,3 +1,5 @@
+import { GraphQLError } from "graphql";
+import { Schema } from "./definitions";
 import { FeatureDefinition, FeatureDefinitions, FeatureUrl } from "./specs/coreSpec";
 
 const registeredFeatures = new Map<string, FeatureDefinitions>();
@@ -12,6 +14,19 @@ export function coreFeatureDefinitionIfKnown(url: FeatureUrl): FeatureDefinition
   return registeredFeatures.get(url.identity)?.find(url.version);
 }
 
+export function validateKnownFeatures(
+  schema: Schema,
+  errorCollector: GraphQLError[] = [],
+): GraphQLError[] {
+  registeredFeatures.forEach(definitions => {
+    const feature = definitions.latest();
+    if (feature.validateSubgraphSchema !== FeatureDefinition.prototype.validateSubgraphSchema) {
+      errorCollector.push(...feature.validateSubgraphSchema(schema));
+    }
+  });
+  return errorCollector;
+}
+
 /**
  * Removes a feature from the set of known features.
  *

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}`)
       }
     }
@@ -355,10 +368,23 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     if (this.name === typenameFieldName) {
       return parentType.typenameField()?.type;
     }
-
-    return this.canRebaseOn(parentType)
+    
+    const returnType = this.canRebaseOn(parentType)
       ? parentType.field(this.name)?.type
       : undefined;
+      
+    // If the field has an argument with fromContextDirective on it. We should not rebase it.
+    const fromContextDirective = federationMetadata(parentType.schema())?.fromContextDirective();
+    if (fromContextDirective && isFederationDirectiveDefinedInSchema(fromContextDirective)) {
+      const fieldInParent = parentType.field(this.name);
+      if (fieldInParent && fieldInParent.arguments()
+          .some(arg => arg.appliedDirectivesOf(fromContextDirective).length > 0 && (!this.args || this.args[arg.name] === undefined))
+        ) {
+        return undefined;
+      }  
+    }
+
+    return returnType;
   }
 
   hasDefer(): boolean {
@@ -1998,10 +2024,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 +2546,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 +3061,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 +3981,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 +4006,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/coreSpec.ts

@@ -117,6 +117,11 @@ export abstract class FeatureDefinition {
       .concat(this.typeSpecs().map((spec) => spec.name));
   }
 
+  // No-op implementation that can be overridden by subclasses.
+  validateSubgraphSchema(_schema: Schema): GraphQLError[] {
+    return [];
+  }
+
   protected nameInSchema(schema: Schema): string | undefined {
     const feature = this.featureInSchema(schema);
     return feature?.nameInSchema;

package/src/specs/federationSpec.ts

@@ -18,11 +18,14 @@ import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 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 {
@@ -40,6 +43,11 @@ export enum FederationDirectiveName {
   AUTHENTICATED = 'authenticated',
   REQUIRES_SCOPES = 'requiresScopes',
   POLICY = 'policy',
+  SOURCE_API = 'sourceAPI',
+  SOURCE_TYPE = 'sourceType',
+  SOURCE_FIELD = 'sourceField',
+  CONTEXT = 'context',
+  FROM_CONTEXT = 'fromContext',
 }
 
 const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
@@ -166,6 +174,14 @@ export class FederationSpecDefinition extends FeatureDefinition {
     if (version.gte(new FeatureVersion(2, 6))) {
       this.registerSubFeature(POLICY_VERSIONS.find(new FeatureVersion(0, 1))!);
     }
+
+    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))!);
+    }
   }
 }
 
@@ -177,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);