@apollo/federation-internals 2.0.0-preview.9 → 2.0.2-alpha.0

package/src/joinSpec.ts

@@ -1,5 +1,5 @@
 import { DirectiveLocation, GraphQLError } from 'graphql';
-import { FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from "./coreSpec";
+import { CorePurpose, FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from "./coreSpec";
 import {
   DirectiveDefinition,
   EnumType,
@@ -176,6 +176,10 @@ export class JoinSpecDefinition extends FeatureDefinition {
   ownerDirective(schema: Schema): DirectiveDefinition<{graph: string}> | undefined {
     return this.directive(schema, 'owner');
   }
+
+  get defaultCorePurpose(): CorePurpose | undefined {
+    return 'EXECUTION';
+  }
 }
 
 // Note: This declare a no-yet-agreed-upon join spec v0.2, that:

package/src/operations.ts

@@ -42,6 +42,7 @@ import {
   typenameFieldName,
   NamedType,
 } from "./definitions";
+import { sameType } from "./types";
 import { assert, mapEntries, MapWithCachedArrays, MultiMap } from "./utils";
 import { argumentsEquals, argumentsFromAST, isValidValue, valueToAST, valueToString } from "./values";
 
@@ -305,6 +306,37 @@ export function sameOperationPaths(p1: OperationPath, p2: OperationPath): boolea
   return true;
 }
 
+export function concatOperationPaths(head: OperationPath, tail: OperationPath): OperationPath {
+  // While this is mainly a simple array concatenation, we optimize slightly by recognizing if the
+  // tail path starts by a fragment selection that is useless given the end of the head path.
+  if (head.length === 0) {
+    return tail;
+  }
+  if (tail.length === 0) {
+    return head;
+  }
+  const lastOfHead = head[head.length - 1];
+  const firstOfTail = tail[0];
+  if (isUselessFollowupElement(lastOfHead, firstOfTail)) {
+    tail = tail.slice(1);
+  }
+  return head.concat(tail);
+}
+
+function isUselessFollowupElement(first: OperationElement, followup: OperationElement): boolean {
+  const typeOfFirst = first.kind === 'Field'
+    ? baseType(first.definition.type!)
+    : first.typeCondition;
+
+  // The followup is useless if it's a fragment (with no directives we would want to preserve) whose type
+  // is already that of the first element.
+  return !!typeOfFirst
+    && followup.kind === 'FragmentElement'
+    && !!followup.typeCondition
+    && followup.appliedDirectives.length === 0
+    && sameType(typeOfFirst, followup.typeCondition);
+}
+
 export type RootOperationPath = {
   rootKind: SchemaRootKind,
   path: OperationPath
@@ -604,6 +636,23 @@ export class SelectionSet {
     return withExpanded;
   }
 
+  /**
+   * Returns the selection select from filtering out any selection that does not match the provided predicate.
+   *
+   * Please that this method will expand *ALL* fragments as the result of applying it's filtering. You should
+   * call `optimize` on the result if you want to re-apply some fragments.
+   */
+  filter(predicate: (selection: Selection) => boolean): SelectionSet {
+    const filtered = new SelectionSet(this.parentType, this.fragments);
+    for (const selection of this.selections()) {
+      const filteredSelection = selection.filter(predicate);
+      if (filteredSelection) {
+        filtered.add(filteredSelection);
+      }
+    }
+    return filtered;
+  }
+
   mergeIn(selectionSet: SelectionSet) {
     for (const selection of selectionSet.selections()) {
       this.add(selection);
@@ -940,6 +989,16 @@ export class FieldSelection {
       : new FieldSelection(this.field, optimizedSelection);
   }
 
+  filter(predicate: (selection: Selection) => boolean): FieldSelection | undefined {
+    if (!predicate(this)) {
+      return undefined;
+    }
+    if (!this.selectionSet) {
+      return this;
+    }
+    return new FieldSelection(this.field, this.selectionSet.filter(predicate));
+  }
+
   expandFragments(names?: string[], updateSelectionSetFragments: boolean = true): FieldSelection {
     const expandedSelection = this.selectionSet ? this.selectionSet.expandFragments(names, updateSelectionSetFragments) : undefined;
     return this.selectionSet === expandedSelection
@@ -1055,7 +1114,6 @@ export abstract class FragmentSelection {
 
   abstract validate(): void;
 
-
   usedVariables(): Variables {
     return mergeVariables(this.element().variables(), this.selectionSet.usedVariables());
   }
@@ -1065,6 +1123,15 @@ export abstract class FragmentSelection {
     return this.element() === updatedFragment ? this : new InlineFragmentSelection(updatedFragment, this.selectionSet);
   }
 
+  filter(predicate: (selection: Selection) => boolean): InlineFragmentSelection | undefined {
+    if (!predicate(this)) {
+      return undefined;
+    }
+    // Note that we essentially expand all fragments as part of this.
+    return new InlineFragmentSelection(this.element(), this.selectionSet.filter(predicate));
+  }
+
+
   equals(that: Selection): boolean {
     if (this === that) {
       return true;
@@ -1144,7 +1211,6 @@ class InlineFragmentSelection extends FragmentSelection {
     };
   }
 
-
   optimize(fragments: NamedFragments): FragmentSelection {
     const optimizedSelection = this.selectionSet.optimize(fragments);
     const typeCondition = this.element().typeCondition;

package/src/precompute.ts

@@ -5,8 +5,6 @@ import {
   federationMetadata,
   FieldDefinition,
   collectTargetFields,
-  InterfaceType,
-  ObjectType,
   Schema,
 } from ".";
 
@@ -33,7 +31,7 @@ export function computeShareables(schema: Schema): (field: FieldDefinition<Compo
     }
   };
 
-  for (const type of schema.types<ObjectType>('ObjectType')) {
+  for (const type of schema.objectTypes()) {
     addKeyFields(type);
     const shareablesOnType = shareableDirective ? type.appliedDirectivesOf(shareableDirective) : [];
     for (const field of type.fields()) {
@@ -59,7 +57,7 @@ export function computeShareables(schema: Schema): (field: FieldDefinition<Compo
     }
   }
 
-  for (const type of schema.types<InterfaceType>('InterfaceType')) {
+  for (const type of schema.interfaceTypes()) {
     addKeyFields(type);
   }
 

package/src/schemaUpgrader.ts

@@ -7,11 +7,11 @@ import {
 import { ERRORS } from "./error";
 import {
   baseType,
+  CompositeType,
   Directive,
   errorCauses,
   Extension,
   FieldDefinition,
-  InterfaceType,
   isCompositeType,
   isInterfaceType,
   isObjectType,
@@ -34,6 +34,7 @@ import {
 } from "./federation";
 import { assert, firstOf, MultiMap } from "./utils";
 import { FEDERATION_SPEC_TYPES } from "./federationSpec";
+import { valueEquals } from "./values";
 
 export type UpgradeResult = UpgradeSuccess | UpgradeFailure;
 
@@ -67,6 +68,7 @@ export type UpgradeChange =
   | ProvidesOrRequiresOnInterfaceFieldRemoval
   | ProvidesOnNonCompositeRemoval
   | FieldsArgumentCoercionToString
+  | RemovedTagOnExternal
 ;
 
 export class ExternalOnTypeExtensionRemoval {
@@ -199,6 +201,16 @@ export class FieldsArgumentCoercionToString {
   }
 }
 
+export class RemovedTagOnExternal {
+  readonly id = 'REMOVED_TAG_ON_EXTERNAL' as const;
+
+  constructor(readonly application: string, readonly element: string) {}
+
+  toString() {
+    return `Removed ${this.application} application on @external "${this.element}" as the @tag application is on another definition`;
+  }
+}
+
 export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
   const changes: Map<string, UpgradeChanges> = new Map();
   if (inputs.values().every((s) => s.isFed2Subgraph())) {
@@ -266,6 +278,11 @@ function resolvesField(subgraph: Subgraph, field: FieldDefinition<ObjectType>):
   return !!f && (!metadata.isFieldExternal(f) || metadata.isFieldPartiallyExternal(f));
 }
 
+function getField(schema: Schema, typeName: string, fieldName: string): FieldDefinition<CompositeType> | undefined {
+  const type = schema.type(typeName);
+  return type && isCompositeType(type) ? type.field(fieldName) : undefined;
+}
+
 class SchemaUpgrader {
   private readonly changes = new MultiMap<UpgradeChangeID, UpgradeChange>();
   private readonly schema: Schema;
@@ -279,8 +296,28 @@ class SchemaUpgrader {
     // later merge errors "AST" nodes ends up pointing to the original schema, the one that make sense to the user.
     this.schema = originalSubgraph.schema.clone();
     this.renameFederationTypes();
-    setSchemaAsFed2Subgraph(this.schema);
+    // Setting this property before trying to switch the cloned schema to fed2 because on
+    // errors `addError` uses `this.subgraph.name`.
     this.subgraph = new Subgraph(originalSubgraph.name, originalSubgraph.url, this.schema);
+    try {
+      setSchemaAsFed2Subgraph(this.schema);
+    } catch (e) {
+      // This could error out if some directive definition clashes with a federation one while
+      // having an incompatible definition. Note that in that case, the choices for the user
+      // are either:
+      // 1. fix/remove the definition if they did meant the federation directive, just had an
+      //   invalid definition.
+      // 2. but if they have their own directive whose name happens to clash with a federation
+      //   directive one but is genuinely a different directive, they will have to move their
+      //   schema to a fed2 one and use renaming.
+      const causes = errorCauses(e);
+      if (causes) {
+        causes.forEach((c) => this.addError(c));
+      } else {
+        // An unexpected exception, rethrow.
+        throw e;
+      }
+    }
     this.metadata = this.subgraph.metadata();
   }
 
@@ -365,6 +402,8 @@ class SchemaUpgrader {
 
     this.addShareable();
 
+    this.removeTagOnExternal();
+
     // If we had errors during the upgrade, we throw them before trying to validate the resulting subgraph, because any invalidity in the
     // migrated subgraph may well due to those migration errors and confuse users.
     if (this.errors.length > 0) {
@@ -434,7 +473,7 @@ class SchemaUpgrader {
   }
 
   private removeExternalOnInterface() {
-    for (const itf of this.schema.types<InterfaceType>('InterfaceType')) {
+    for (const itf of this.schema.interfaceTypes()) {
       for (const field of itf.fields()) {
         const external = this.external(field);
         if (external) {
@@ -590,7 +629,7 @@ class SchemaUpgrader {
   }
 
   private removeDirectivesOnInterface() {
-    for (const type of this.schema.types<InterfaceType>('InterfaceType')) {
+    for (const type of this.schema.interfaceTypes()) {
       for (const application of type.appliedDirectivesOf(this.metadata.keyDirective())) {
         this.addChange(new KeyOnInterfaceRemoval(type.name));
         application.remove();
@@ -607,7 +646,7 @@ class SchemaUpgrader {
   }
 
   private removeProvidesOnNonComposite() {
-    for (const type of this.schema.types<ObjectType>('ObjectType')) {
+    for (const type of this.schema.objectTypes()) {
       for (const field of type.fields()) {
         if (isCompositeType(baseType(field.type!))) {
           continue;
@@ -627,7 +666,7 @@ class SchemaUpgrader {
     // We add shareable:
     // - to every "value type" (in the fed1 sense of non-root type and non-entity) if it is used in any other subgraphs
     // - to any (non-external) field of an entity/root-type that is not a key field and if another subgraphs resolve it (fully or partially through @provides)
-    for (const type of this.schema.types<ObjectType>('ObjectType')) {
+    for (const type of this.schema.objectTypes()) {
       if (type.hasAppliedDirective(keyDirective) || type.isRootType()) {
         for (const field of type.fields()) {
           // To know if the field is a "key" field which doesn't need shareable, we rely on whether the field is shareable in the original
@@ -651,4 +690,29 @@ class SchemaUpgrader {
       }
     }
   }
+
+  private removeTagOnExternal() {
+    const tagDirective = this.schema.directive('tag');
+    if (!tagDirective) {
+      return;
+    }
+
+    for (const application of tagDirective.applications()) {
+      const element = application.parent;
+      if (!(element instanceof FieldDefinition)) {
+        continue;
+      }
+      if (this.external(element)) {
+        const tagIsUsedInOtherDefinition = this.otherSubgraphs
+          .map((s) => getField(s.schema, element.parent.name, element.name))
+          .filter((f) => !(f && f.hasAppliedDirective('external')))
+          .some((f) => f && f.appliedDirectivesOf('tag').some((d) => valueEquals(application.arguments(), d.arguments())));
+
+        if (tagIsUsedInOtherDefinition) {
+          this.addChange(new RemovedTagOnExternal(application.toString(), element.coordinate));
+          application.remove();
+        }
+      }
+    }
+  }
 }

package/src/supergraphs.ts

@@ -14,6 +14,7 @@ const SUPPORTED_FEATURES = new Set([
   'https://specs.apollo.dev/tag/v0.1',
   'https://specs.apollo.dev/tag/v0.2',
   'https://specs.apollo.dev/inaccessible/v0.1',
+  'https://specs.apollo.dev/inaccessible/v0.2',
 ]);
 
 export function ErrUnsupportedFeature(feature: CoreFeature): Error {

package/src/validate.ts

@@ -129,13 +129,14 @@ class Validator {
     return this.errors;
   }
 
-  private validateHasType(elt: { type?: Type, coordinate: string, sourceAST?: ASTNode }) {
+  private validateHasType(elt: { type?: Type, coordinate: string, sourceAST?: ASTNode }): boolean {
     // Note that this error can't happen if you parse the schema since it wouldn't be valid syntax, but it can happen for
     // programmatically constructed schema.
     if (!elt.type) {
       this.errors.push(new GraphQLError(`Element ${elt.coordinate} does not have a type set`, elt.sourceAST));
       this.hasMissingTypes = false;
     }
+    return !!elt.type;
   }
 
   private validateName(elt: { name: string, sourceAST?: ASTNode}) {
@@ -183,8 +184,7 @@ class Validator {
         // Note that we may not have validated the interface yet, so making sure we have a meaningful error
         // if the type is not set, even if that means a bit of cpu wasted since we'll re-check later (and
         // as many type as the interface is implemented); it's a cheap check anyway.
-        this.validateHasType(itfField);
-        if (!isSubtype(itfField.type!, field.type!)) {
+        if (this.validateHasType(itfField) && !isSubtype(itfField.type!, field.type!)) {
           this.errors.push(new GraphQLError(
             `Interface field ${itfField.coordinate} expects type ${itfField.type} but ${field.coordinate} of type ${field.type} is not a proper subtype.`,
             sourceASTs(itfField, field)
@@ -200,10 +200,8 @@ class Validator {
             ));
             continue;
           }
-          // Same as above for the field
-          this.validateHasType(itfArg);
           // Note that we could use contra-variance but as graphQL-js currently doesn't allow it, we mimic that.
-          if (!sameType(itfArg.type!, arg.type!)) {
+          if (this.validateHasType(itfArg) && !sameType(itfArg.type!, arg.type!)) {
             this.errors.push(new GraphQLError(
               `Interface field argument ${itfArg.coordinate} expects type ${itfArg.type} but ${arg.coordinate} is type ${arg.type}.`,
               sourceASTs(itfArg, arg)
@@ -247,19 +245,29 @@ class Validator {
     }
     for (const field of type.fields()) {
       this.validateName(field);
-      this.validateHasType(field);
+      if (!this.validateHasType(field)) {
+        continue;
+      }
       if (field.isRequired() && field.isDeprecated()) {
         this.errors.push(new GraphQLError(
           `Required input field ${field.coordinate} cannot be deprecated.`,
           sourceASTs(field.appliedDirectivesOf('deprecated')[0], field)
         ));
       }
+      if (field.defaultValue !== undefined && !isValidValue(field.defaultValue, field, new VariableDefinitions())) {
+        this.errors.push(new GraphQLError(
+          `Invalid default value (got: ${valueToString(field.defaultValue)}) provided for input field ${field.coordinate} of type ${field.type}.`,
+          sourceASTs(field)
+        ));
+      }
     }
   }
 
   private validateArg(arg: ArgumentDefinition<any>) {
     this.validateName(arg);
-    this.validateHasType(arg);
+    if (!this.validateHasType(arg)) {
+      return;
+    }
     if (arg.isRequired() && arg.isDeprecated()) {
       this.errors.push(new GraphQLError(
         `Required argument ${arg.coordinate} cannot be deprecated.`,
@@ -305,7 +313,10 @@ class Validator {
         // Again, that implies that value is not required.
         continue;
       }
-      if (!isValidValue(value, argument, this.emptyVariables)) {
+      // Note that we validate if the definition argument has a type set separatly
+      // and log an error if necesary, but we just want to avoid calling
+      // `isValidValue` if there is not type as it may throw.
+      if (argument.type && !isValidValue(value, argument, this.emptyVariables)) {
         const parent = application.parent;
         // The only non-named SchemaElement is the `schema` definition.
         const parentDesc = parent instanceof NamedSchemaElement

package/src/values.ts

@@ -1,5 +1,6 @@
 import {
   ArgumentDefinition,
+  InputFieldDefinition,
   InputObjectType,
   InputType,
   isBooleanType,
@@ -38,16 +39,29 @@ import { assert, assertUnreachable } from './utils';
 const MAX_INT = 2147483647;
 const MIN_INT = -2147483648;
 
+/**
+ * Converts a graphQL value into it's textual representation.
+ *
+ * @param v - the value to convert/display. This method assumes that it is a value graphQL
+ *   value (essentially, one that could have been produced by `valueFromAST`/`valueFormASTUntyped`).
+ *   If this is not the case, the behaviour is unspecified, and in particular this method may
+ *   throw or produce an output that is not valid graphQL syntax.
+ * @param expectedType - the type of the value being converted. This is optional is only used to
+ *   ensure enum values are displayed as such and not as strings. In other words, the type of
+ *   the value should be provided when possible (when the value is known to be of a ype) but
+ *   using this method without a type is useful to dispaly the value in error/debug messages
+ *   where no type may be known. Note that if `v` is not a valid value for `expectedType`,
+ *   this method will not throw but enum values may be represented by strings in the output.
+ * @return a textual representation of the value. It is guaranteed to  be valid graphQL syntax
+ *   if the input value is a valid graphQL value.
+ */
 export function valueToString(v: any, expectedType?: InputType): string {
   if (v === undefined || v === null) {
-    if (expectedType && isNonNullType(expectedType)) {
-      throw buildError(`Invalid undefined/null value for non-null type ${expectedType}`);
-    }
     return "null";
   }
 
   if (expectedType && isNonNullType(expectedType)) {
-    expectedType = expectedType.ofType;
+    return valueToString(v, expectedType.ofType);
   }
 
   if (expectedType && isCustomScalarType(expectedType)) {
@@ -61,18 +75,26 @@ export function valueToString(v: any, expectedType?: InputType): string {
 
   if (Array.isArray(v)) {
     let elementsType: InputType | undefined = undefined;
-    if (expectedType) {
-      if (!isListType(expectedType)) {
-        throw buildError(`Invalid list value for non-list type ${expectedType}`);
-      }
+    // If the expected type is not a list, we've been given an invalid type. We don't want this
+    // method to fail though, so we just ignore the provided type from that point one (passing
+    // `undefined` to the recursion).
+    if (expectedType && isListType(expectedType)) {
       elementsType = expectedType.ofType;
     }
     return '[' + v.map(e => valueToString(e, elementsType)).join(', ') + ']';
   }
 
+  // We know the value is not a list/array. But if the type is a list, we still want to print
+  // the value correctly, at least as long as it's a valid value for the element type, since
+  // list input coercions may allow this.
+  if (expectedType && isListType(expectedType)) {
+    return valueToString(v, expectedType.ofType);
+  }
+
   if (typeof v === 'object') {
     if (expectedType && !isInputObjectType(expectedType)) {
-      throw buildError(`Invalid object value for non-input-object type ${expectedType} (isCustomScalar? ${isCustomScalarType(expectedType)})`);
+      // expectedType does not match the value, we ignore it for what remains.
+      expectedType = undefined;
     }
     return '{' + Object.keys(v).map(k => {
       const valueType = expectedType ? (expectedType as InputObjectType).field(k)?.type : undefined;
@@ -462,7 +484,7 @@ function areTypesCompatible(variableType: InputType, locationType: InputType): b
   return !isListType(variableType) && sameType(variableType, locationType);
 }
 
-export function isValidValue(value: any, argument: ArgumentDefinition<any>, variableDefinitions: VariableDefinitions): boolean {
+export function isValidValue(value: any, argument: ArgumentDefinition<any> | InputFieldDefinition, variableDefinitions: VariableDefinitions): boolean {
   return isValidValueApplication(value, argument.type!, argument.defaultValue, variableDefinitions);
 }
 
@@ -499,8 +521,13 @@ function isValidValueApplication(value: any, locationType: InputType, locationDe
     if (typeof value !== 'object') {
       return false;
     }
-    const isValid = locationType.fields().every(field => isValidValueApplication(value[field.name], field.type!, undefined, variableDefinitions));
-    return isValid;
+    const valueKeys = new Set(Object.keys(value));
+    const fieldsAreValid = locationType.fields().every(field => {
+      valueKeys.delete(field.name);
+      return isValidValueApplication(value[field.name], field.type!, undefined, variableDefinitions)
+    });
+    const hasUnexpectedField = valueKeys.size !== 0
+    return fieldsAreValid && !hasUnexpectedField;
   }
 
   // TODO: we may have to handle some coercions (not sure it matters in our use case