@apollo/federation-internals 2.0.0-preview.1 → 2.0.0-preview.12

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/print.ts

@@ -140,7 +140,7 @@ function printSchemaDefinitionOrExtension(
   }
   const rootEntries = orderRoots(roots, options).map((rootType) => `${options.indentString}${rootType.rootKind}: ${rootType.type}`);
   // Note that that the description is never written with the extension as `extend schema` doesn _not_ support descriptions
-  return (extension ? '' : printDescription(schemaDefinition, options))
+  return printDescription(schemaDefinition, options, extension)
     + printIsExtension(extension)
     + 'schema'
     + printAppliedDirectives(directives, options, true, rootEntries.length !== 0)
@@ -187,7 +187,7 @@ export function printTypeDefinitionAndExtensions(type: NamedType, options: Print
 
 export function printDirectiveDefinition(directive: DirectiveDefinition, options: PrintOptions): string {
   const locations = directive.locations.join(' | ');
-  return `${printDescription(directive, options)}directive ${directive}${printArgs(directive.arguments(), options)}${directive.repeatable ? ' repeatable' : ''} on ${locations}`;
+  return `${printDescription(directive, options, null)}directive ${directive}${printArgs(directive.arguments(), options)}${directive.repeatable ? ' repeatable' : ''} on ${locations}`;
 }
 
 function printAppliedDirectives(
@@ -207,10 +207,12 @@ function printAppliedDirectives(
 function printDescription(
   element: SchemaElement<any, any>,
   options: PrintOptions,
+  extension: Extension<any> | undefined | null,
   indentation: string = '',
   firstInBlock: boolean = true
 ): string {
-  if (element.description === undefined || options.noDescriptions) {
+  // Note that extensions cannot have descriptions (it's not syntactically valid)
+  if (extension || element.description === undefined || options.noDescriptions) {
     return '';
   }
 
@@ -227,7 +229,7 @@ function printScalarDefinitionOrExtension(type: ScalarType, options: PrintOption
   if (extension && !directives.length) {
     return undefined;
   }
-  return `${printDescription(type, options)}${printIsExtension(extension)}scalar ${type.name}${printAppliedDirectives(directives, options, true, false)}`
+  return `${printDescription(type, options, extension)}${printIsExtension(extension)}scalar ${type.name}${printAppliedDirectives(directives, options, true, false)}`
 }
 
 function printImplementedInterfaces(implementations: readonly InterfaceImplementation<any>[]): string {
@@ -246,7 +248,7 @@ function printFieldBasedTypeDefinitionOrExtension(kind: string, type: ObjectType
   if (!directives.length && !interfaces.length && !fields.length) {
     return undefined;
   }
-  return printDescription(type, options)
+  return printDescription(type, options, extension)
     + printIsExtension(extension)
     + kind + ' ' + type
     + printImplementedInterfaces(interfaces)
@@ -262,7 +264,7 @@ function printUnionDefinitionOrExtension(type: UnionType, options: PrintOptions,
     return undefined;
   }
   const possibleTypes = members.length ? ' = ' + members.map(m => m.type).join(' | ') : '';
-  return printDescription(type, options)
+  return printDescription(type, options, extension)
     + printIsExtension(extension)
     + 'union ' + type
     + printAppliedDirectives(directives, options, true, members.length > 0)
@@ -276,11 +278,11 @@ function printEnumDefinitionOrExtension(type: EnumType, options: PrintOptions, e
     return undefined;
   }
   const vals = values.map((v, i) =>
-    printDescription(v, options, options.indentString, !i)
+    printDescription(v, options, extension, options.indentString, !i)
     + options.indentString
     + v
     + printAppliedDirectives(v.appliedDirectives, options));
-  return printDescription(type, options)
+  return printDescription(type, options, extension)
     + printIsExtension(extension)
     + 'enum ' + type
     + printAppliedDirectives(directives, options, true, vals.length > 0)
@@ -294,7 +296,7 @@ function printInputDefinitionOrExtension(type: InputObjectType, options: PrintOp
   if (!directives.length && !fields.length) {
     return undefined;
   }
-  return printDescription(type, options)
+  return printDescription(type, options, extension)
     + printIsExtension(extension)
     + 'input ' + type
     + printAppliedDirectives(directives, options, true, fields.length > 0)
@@ -304,7 +306,7 @@ function printInputDefinitionOrExtension(type: InputObjectType, options: PrintOp
 
 function printFields(fields: readonly (FieldDefinition<any> | InputFieldDefinition)[], options: PrintOptions): string {
   return printBlock(fields.map((f, i) =>
-    printDescription(f, options, options.indentString, !i)
+    printDescription(f, options, undefined, options.indentString, !i)
     + options.indentString
     + printField(f, options)
     + printAppliedDirectives(f.appliedDirectives, options)));
@@ -332,7 +334,7 @@ function printArgs(args: readonly ArgumentDefinition<any>[], options: PrintOptio
   }
 
   const formattedArgs = args
-    .map((arg, i) => printDescription(arg, options, '  ' + indentation, !i) + '  ' + indentation + printArg(arg, options))
+    .map((arg, i) => printDescription(arg, options, null, '  ' + indentation, !i) + '  ' + indentation + printArg(arg, options))
     .join('\n');
   return `(\n${formattedArgs}\n${indentation})`;
 }

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());
@@ -435,7 +433,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 +520,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 +562,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 +589,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 +606,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 +626,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,28 +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.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}> {
@@ -33,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