@apollo/federation-internals 2.0.0-preview.7 → 2.0.0

package/src/index.ts

@@ -10,8 +10,10 @@ export * from './debug';
 export * from './coreSpec';
 export * from './joinSpec';
 export * from './tagSpec';
+export * from './inaccessibleSpec';
 export * from './federationSpec';
 export * from './supergraphs';
 export * from './extractSubgraphsFromSupergraph';
 export * from './error';
 export * from './schemaUpgrader';
+export * from './suggestions';

package/src/introspection.ts

@@ -35,13 +35,15 @@ export function addIntrospectionFields(schema: Schema) {
   typeType.addField('possibleTypes', new ListType(new NonNullType(typeType)));
   typeType.addField('enumValues', new ListType(new NonNullType(enumValueType)))
     .addArgument('includeDeprecated', schema.booleanType(), false);
-  typeType.addField('inputFields', new ListType(new NonNullType(inputValueType)));
+  typeType.addField('inputFields', new ListType(new NonNullType(inputValueType)))
+    .addArgument('includeDeprecated', schema.booleanType(), false);
   typeType.addField('ofType', typeType);
   typeType.addField('specifiedByURL', schema.stringType());
 
   fieldType.addField('name', new NonNullType(schema.stringType()));
   fieldType.addField('description', schema.stringType());
-  fieldType.addField('args', new NonNullType(new ListType(new NonNullType(inputValueType))));
+  fieldType.addField('args', new NonNullType(new ListType(new NonNullType(inputValueType))))
+    .addArgument('includeDeprecated', schema.booleanType(), false);
   fieldType.addField('type', new NonNullType(typeType));
   fieldType.addField('isDeprecated', new NonNullType(schema.booleanType()));
   fieldType.addField('deprecationReason', schema.stringType());
@@ -50,6 +52,8 @@ export function addIntrospectionFields(schema: Schema) {
   inputValueType.addField('description', schema.stringType());
   inputValueType.addField('type', new NonNullType(typeType));
   inputValueType.addField('defaultValue', schema.stringType());
+  inputValueType.addField('isDeprecated', new NonNullType(schema.booleanType()));
+  inputValueType.addField('deprecationReason', schema.stringType());
 
   enumValueType.addField('name', new NonNullType(schema.stringType()));
   enumValueType.addField('description', schema.stringType());
@@ -65,7 +69,8 @@ export function addIntrospectionFields(schema: Schema) {
   directiveType.addField('name', new NonNullType(schema.stringType()));
   directiveType.addField('description', schema.stringType());
   directiveType.addField('locations', new NonNullType(new ListType(new NonNullType(directiveLocationEnum))));
-  directiveType.addField('args', new NonNullType(new ListType(new NonNullType(inputValueType))));
+  directiveType.addField('args', new NonNullType(new ListType(new NonNullType(inputValueType))))
+    .addArgument('includeDeprecated', schema.booleanType(), false);
   directiveType.addField('isRepeatable', new NonNullType(schema.booleanType()));
 
   const schemaType = schema.addType(new ObjectType('__Schema', true));

package/src/joinSpec.ts

@@ -1,4 +1,4 @@
-import { DirectiveLocation } from 'graphql';
+import { DirectiveLocation, GraphQLError } from 'graphql';
 import { FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from "./coreSpec";
 import {
   DirectiveDefinition,
@@ -8,6 +8,7 @@ import {
   NonNullType,
 } from "./definitions";
 import { Subgraph, Subgraphs } from "./federation";
+import { registerKnownFeature } from './knownCoreFeatures';
 import { MultiMap } from "./utils";
 
 export const joinIdentity = 'https://specs.apollo.dev/join';
@@ -38,7 +39,7 @@ export class JoinSpecDefinition extends FeatureDefinition {
     return this.version.equals(new FeatureVersion(0, 1));
   }
 
-  addElementsToSchema(schema: Schema) {
+  addElementsToSchema(schema: Schema): GraphQLError[] {
     const joinGraph = this.addDirective(schema, 'graph').addLocations(DirectiveLocation.ENUM_VALUE);
     joinGraph.addArgument('name', new NonNullType(schema.stringType()));
     joinGraph.addArgument('url', new NonNullType(schema.stringType()));
@@ -73,6 +74,8 @@ export class JoinSpecDefinition extends FeatureDefinition {
     if (!this.isV01()) {
       joinField.addArgument('type', schema.stringType());
       joinField.addArgument('external', schema.booleanType());
+      joinField.addArgument('override', schema.stringType());
+      joinField.addArgument('usedOverridden', schema.booleanType());
     }
 
     if (!this.isV01()) {
@@ -88,6 +91,23 @@ export class JoinSpecDefinition extends FeatureDefinition {
       const joinOwner = this.addDirective(schema, 'owner').addLocations(DirectiveLocation.OBJECT);
       joinOwner.addArgument('graph', new NonNullType(graphEnum));
     }
+    return [];
+  }
+
+  allElementNames(): string[] {
+    const names = [
+      'graph',
+      'Graph',
+      'FieldSet',
+      '@type',
+      '@field',
+    ];
+    if (this.isV01()) {
+      names.push('@owner');
+    } else {
+      names.push('@implements');
+    }
+    return names;
   }
 
   populateGraphEnum(schema: Schema, subgraphs: Subgraphs): Map<string, string> {
@@ -141,7 +161,15 @@ export class JoinSpecDefinition extends FeatureDefinition {
     return this.directive(schema, 'implements');
   }
 
-  fieldDirective(schema: Schema): DirectiveDefinition<{graph: string, requires?: string, provides?: string, type?: string, external?: boolean}> {
+  fieldDirective(schema: Schema): DirectiveDefinition<{
+    graph: string,
+    requires?: string,
+    provides?: string,
+    override?: string,
+    type?: string,
+    external?: boolean,
+    usedOverridden?: boolean,
+  }> {
     return this.directive(schema, 'field')!;
   }
 
@@ -160,3 +188,5 @@ export class JoinSpecDefinition extends FeatureDefinition {
 export const JOIN_VERSIONS = new FeatureDefinitions<JoinSpecDefinition>(joinIdentity)
   .add(new JoinSpecDefinition(new FeatureVersion(0, 1)))
   .add(new JoinSpecDefinition(new FeatureVersion(0, 2)));
+
+registerKnownFeature(JOIN_VERSIONS);

package/src/knownCoreFeatures.ts

@@ -0,0 +1,13 @@
+import { FeatureDefinition, FeatureDefinitions, FeatureUrl } from "./coreSpec";
+
+const registeredFeatures: Map<string, FeatureDefinitions> = new Map();
+
+export function registerKnownFeature(definitions: FeatureDefinitions) {
+  if (!registeredFeatures.has(definitions.identity)) {
+    registeredFeatures.set(definitions.identity, definitions);
+  }
+}
+
+export function coreFeatureDefinitionIfKnown(url: FeatureUrl): FeatureDefinition | undefined {
+  return registeredFeatures.get(url.identity)?.find(url.version);
+}

package/src/operations.ts

@@ -862,6 +862,21 @@ export class SelectionSet {
   }
 }
 
+export function allFieldDefinitionsInSelectionSet(selection: SelectionSet): FieldDefinition<CompositeType>[] {
+  const stack = Array.from(selection.selections());
+  const allFields: FieldDefinition<CompositeType>[] = [];
+  while (stack.length > 0) {
+    const selection = stack.pop()!;
+    if (selection.kind === 'FieldSelection') {
+      allFields.push(selection.field.definition);
+    }
+    if (selection.selectionSet) {
+      stack.push(...selection.selectionSet.selections());
+    }
+  }
+  return allFields;
+}
+
 export function selectionSetOfElement(element: OperationElement, subSelection?: SelectionSet): SelectionSet {
   const selectionSet = new SelectionSet(element.parentType);
   selectionSet.add(selectionOfElement(element, subSelection));

package/src/{sharing.ts → precompute.ts}

@@ -5,9 +5,7 @@ import {
   federationMetadata,
   FieldDefinition,
   collectTargetFields,
-  InterfaceType,
-  ObjectType,
-  Schema
+  Schema,
 } from ".";
 
 export function computeShareables(schema: Schema): (field: FieldDefinition<CompositeType>) => boolean {
@@ -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,10 +57,9 @@ export function computeShareables(schema: Schema): (field: FieldDefinition<Compo
     }
   }
 
-  for (const type of schema.types<InterfaceType>('InterfaceType')) {
+  for (const type of schema.interfaceTypes()) {
     addKeyFields(type);
   }
 
   return (field) => shareableFields.has(field.coordinate);
 }
-

package/src/schemaUpgrader.ts

@@ -11,7 +11,6 @@ import {
   errorCauses,
   Extension,
   FieldDefinition,
-  InterfaceType,
   isCompositeType,
   isInterfaceType,
   isObjectType,
@@ -24,7 +23,6 @@ import {
 import {
   addSubgraphToError,
   collectTargetFields,
-  collectUsedExternalFieldsCoordinates,
   federationMetadata,
   FederationMetadata,
   printSubgraphNames,
@@ -43,7 +41,7 @@ type UpgradeChanges = MultiMap<UpgradeChangeID, UpgradeChange>;
 export type UpgradeSuccess = {
   subgraphs: Subgraphs,
   changes: Map<string, UpgradeChanges>,
-  errors?: never, 
+  errors?: never,
 }
 
 export type UpgradeFailure = {
@@ -235,7 +233,7 @@ export function upgradeSubgraphsIfNecessary(inputs: Subgraphs): UpgradeResult {
  *  2. do not have a definition for the same type in the same subgraph (this is a GraphQL extension otherwise).
  *
  * Not that type extensions in federation 1 generally have a @key but in really the code consider something a type extension even without
- * it (which I'd argue is a unintended bug of fed1 since this leads to various problems) so we don't check for the presence of @key here. 
+ * it (which I'd argue is a unintended bug of fed1 since this leads to various problems) so we don't check for the presence of @key here.
  */
 function isFederationTypeExtension(type: NamedType): boolean {
   const metadata = federationMetadata(type.schema());
@@ -280,8 +278,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();
   }
 
@@ -435,7 +453,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) {
@@ -522,7 +540,7 @@ class SchemaUpgrader {
             continue;
           }
           assert(isCompositeType(typeInOther), () => `Type ${type} is of kind ${type.kind} in ${this.subgraph.name} but ${typeInOther.kind} in ${other.name}`);
-          const keysInOther = typeInOther.appliedDirectivesOf(other.metadata().keyDirective()); 
+          const keysInOther = typeInOther.appliedDirectivesOf(other.metadata().keyDirective());
           if (keysInOther.length === 0) {
             continue;
           }
@@ -564,14 +582,12 @@ class SchemaUpgrader {
   }
 
   private removeUnusedExternals() {
-    const usedExternalFieldsCoordinates = collectUsedExternalFieldsCoordinates(this.metadata);
-
     for (const type of this.schema.types()) {
       if (!isObjectType(type) && !isInterfaceType(type)) {
         continue;
       }
       for (const field of type.fields()) {
-        if (this.metadata.isFieldExternal(field) && !usedExternalFieldsCoordinates.has(field.coordinate)) {
+        if (this.metadata.isFieldExternal(field) && !this.metadata.isFieldUsed(field)) {
           this.addChange(new UnusedExternalRemoval(field.coordinate));
           field.remove();
         }
@@ -593,7 +609,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();
@@ -610,7 +626,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;
@@ -630,7 +646,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

package/src/suggestions.ts

@@ -5,7 +5,7 @@ import { mapKeys } from './utils';
  * Given an invalid input string and a list of valid options, returns a filtered
  * list of valid options sorted based on their similarity with the input.
  */
-export function suggestionList(input: string, options: string[]): string[] {
+export function suggestionList(input: string, options: readonly string[]): string[] {
   const optionsByDistance = new Map<string, number>();
 
   const threshold = Math.floor(input.length * 0.4) + 1;

package/src/supergraphs.ts

@@ -12,7 +12,9 @@ const SUPPORTED_FEATURES = new Set([
   'https://specs.apollo.dev/join/v0.1',
   'https://specs.apollo.dev/join/v0.2',
   '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/tagSpec.ts

@@ -1,29 +1,55 @@
 import { DirectiveLocation, GraphQLError } from "graphql";
 import { FeatureDefinition, FeatureDefinitions, FeatureUrl, FeatureVersion } from "./coreSpec";
 import { DirectiveDefinition, NonNullType, Schema } from "./definitions";
+import { createDirectiveSpecification, DirectiveSpecification } from "./directiveAndTypeSpecification";
 import { ERRORS } from "./error";
+import { registerKnownFeature } from "./knownCoreFeatures";
 import { sameType } from "./types";
 
 export const tagIdentity = 'https://specs.apollo.dev/tag';
 
-export const tagLocations = [
-  DirectiveLocation.FIELD_DEFINITION,
-  DirectiveLocation.OBJECT,
-  DirectiveLocation.INTERFACE,
-  DirectiveLocation.UNION,
-];
-
-const printedTagDefinition = 'directive @tag(name: String!) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION';
-
 export class TagSpecDefinition extends FeatureDefinition {
+  public readonly tagLocations: DirectiveLocation[];
+  public readonly tagDirectiveSpec: DirectiveSpecification;
+  private readonly printedTagDefinition: string;
+
   constructor(version: FeatureVersion) {
     super(new FeatureUrl(tagIdentity, 'tag', version));
+    this.tagLocations = [
+      DirectiveLocation.FIELD_DEFINITION,
+      DirectiveLocation.OBJECT,
+      DirectiveLocation.INTERFACE,
+      DirectiveLocation.UNION,
+    ];
+    this.printedTagDefinition = 'directive @tag(name: String!) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION';
+    if (!this.isV01()) {
+      this.tagLocations.push(
+        DirectiveLocation.ARGUMENT_DEFINITION,
+        DirectiveLocation.SCALAR,
+        DirectiveLocation.ENUM,
+        DirectiveLocation.ENUM_VALUE,
+        DirectiveLocation.INPUT_OBJECT,
+        DirectiveLocation.INPUT_FIELD_DEFINITION,
+      );
+      this.printedTagDefinition = 'directive @tag(name: String!) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION';
+    }
+    this.tagDirectiveSpec = createDirectiveSpecification({
+      name:'tag',
+      locations: this.tagLocations,
+      repeatable: true,
+      argumentFct: (schema) => ({
+        args: [{ name: 'name', type: new NonNullType(schema.stringType()) }],
+        errors: [],
+      }),
+    });
   }
 
-  addElementsToSchema(schema: Schema) {
-    const directive = this.addDirective(schema, 'tag').addLocations(...tagLocations);
-    directive.repeatable = true;
-    directive.addArgument("name", new NonNullType(schema.stringType()));
+  private isV01() {
+    return this.version.equals(new FeatureVersion(0, 1));
+  }
+
+  addElementsToSchema(schema: Schema): GraphQLError[] {
+    return this.addDirectiveSpec(schema, this.tagDirectiveSpec);
   }
 
   tagDirective(schema: Schema): DirectiveDefinition<{name: string}> {
@@ -34,16 +60,23 @@ export class TagSpecDefinition extends FeatureDefinition {
     const hasUnknownArguments = Object.keys(definition.arguments()).length > 1;
     const nameArg = definition.argument('name');
     const hasValidNameArg = nameArg && sameType(nameArg.type!, new NonNullType(definition.schema().stringType()));
-    const hasValidLocations = definition.locations.every(loc => tagLocations.includes(loc));
+    const hasValidLocations = definition.locations.every(loc => this.tagLocations.includes(loc));
     if (hasUnknownArguments || !hasValidNameArg || !hasValidLocations) {
       return ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-        message: `Found invalid @tag directive definition. Please ensure the directive definition in your schema's definitions matches the following:\n\t${printedTagDefinition}`,
+        message: `Found invalid @tag directive definition. Please ensure the directive definition in your schema's definitions matches the following:\n\t${this.printedTagDefinition}`,
       }
       );
     }
     return undefined;
   }
+
+  allElementNames(): string[] {
+    return ["@tag"];
+  }
 }
 
 export const TAG_VERSIONS = new FeatureDefinitions<TagSpecDefinition>(tagIdentity)
-  .add(new TagSpecDefinition(new FeatureVersion(0, 1)));
+  .add(new TagSpecDefinition(new FeatureVersion(0, 1)))
+  .add(new TagSpecDefinition(new FeatureVersion(0, 2)));
+
+registerKnownFeature(TAG_VERSIONS);

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