@apollo/federation-internals 2.0.6-rc.0 → 2.1.0-alpha.1

package/src/tagSpec.ts

@@ -62,9 +62,8 @@ export class TagSpecDefinition extends FeatureDefinition {
     const hasValidNameArg = nameArg && sameType(nameArg.type!, new NonNullType(definition.schema().stringType()));
     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${this.printedTagDefinition}`,
-      }
+      return ERRORS.DIRECTIVE_DEFINITION_INVALID.err(
+        `Found invalid @tag directive definition. Please ensure the directive definition in your schema's definitions matches the following:\n\t${this.printedTagDefinition}`,
       );
     }
     return undefined;

package/src/validate.ts

@@ -16,10 +16,11 @@ import {
   UnionType,
   VariableDefinitions
 } from "./definitions";
-import { assertName, ASTNode, GraphQLError } from "graphql";
+import { assertName, ASTNode, GraphQLError, GraphQLErrorOptions } from "graphql";
 import { isValidValue, valueToString } from "./values";
 import { isIntrospectionName } from "./introspection";
 import { isSubtype, sameType } from "./types";
+import { ERRORS } from "./error";
 
 // Note really meant to be called manually as it is part of `Schema.validate`, but separated for core-organization reasons.
 // This mostly apply the validations that graphQL-js does in `validateSchema` which we don't reuse because it applies to
@@ -35,7 +36,7 @@ class InputObjectCircularRefsValidator {
   // Position in the field path
   private readonly fieldPathIndexByTypeName = new Map<string, number>();
 
-  constructor(private readonly onError: (error: GraphQLError) => void) {
+  constructor(private readonly onError: (message: string, options: GraphQLErrorOptions) => void) {
   }
 
   detectCycles(type: InputObjectType) {
@@ -57,10 +58,10 @@ class InputObjectCircularRefsValidator {
         } else {
           const cyclePath = this.fieldPath.slice(cycleIndex);
           const pathStr = cyclePath.map((fieldObj) => fieldObj.name).join('.');
-          this.onError(new GraphQLError(
+          this.onError(
             `Cannot reference Input Object "${fieldType.name}" within itself through a series of non-null fields: "${pathStr}".`,
-            sourceASTs(...cyclePath)
-          ));
+            { nodes: sourceASTs(...cyclePath) },
+          );
         }
         this.fieldPath.pop();
       }
@@ -112,7 +113,7 @@ class Validator {
     // we found any type missing (in which case, there will be some errors and users should fix those
     // first).
     if (!this.hasMissingTypes) {
-      const refsValidator = new InputObjectCircularRefsValidator(e => this.errors.push(e));
+      const refsValidator = new InputObjectCircularRefsValidator((msg, opts) => this.addError(msg, opts));
       for (const type of this.schema.types()) {
         switch (type.kind) {
           case 'ObjectType':
@@ -129,11 +130,15 @@ class Validator {
     return this.errors;
   }
 
+  private addError(message: string, options: GraphQLErrorOptions) {
+    this.errors.push(ERRORS.INVALID_GRAPHQL.err(message, options));
+  }
+
   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.addError(`Element ${elt.coordinate} does not have a type set`, { nodes: elt.sourceAST });
       this.hasMissingTypes = false;
     }
     return !!elt.type;
@@ -146,13 +151,13 @@ class Validator {
     try {
       assertName(elt.name);
     } catch (e) {
-      this.errors.push(elt.sourceAST ? new GraphQLError(e.message, elt.sourceAST) : e);
+      this.addError(e.message, elt.sourceAST ? { nodes: elt.sourceAST } : {});
     }
   }
 
   private validateObjectOrInterfaceType(type: ObjectType | InterfaceType) {
     if (!type.hasFields()) {
-      this.errors.push(new GraphQLError(`Type ${type.name} must define one or more fields.`, type.sourceAST));
+      this.addError(`Type ${type.name} must define one or more fields.`, { nodes: type.sourceAST });
     }
     for (const field of type.fields()) {
       this.validateName(field);
@@ -165,47 +170,47 @@ class Validator {
 
   private validateImplementedInterfaces(type: ObjectType | InterfaceType) {
     if (type.implementsInterface(type.name)) {
-      this.errors.push(new GraphQLError(
+      this.addError(
         `Type ${type} cannot implement itself because it would create a circular reference.`,
-        sourceASTs(type, type.interfaceImplementation(type.name)!)
-      ));
+        { nodes: sourceASTs(type, type.interfaceImplementation(type.name)!) },
+      );
     }
 
     for (const itf of type.interfaces()) {
       for (const itfField of itf.fields()) {
         const field = type.field(itfField.name);
         if (!field) {
-          this.errors.push(new GraphQLError(
+          this.addError(
             `Interface field ${itfField.coordinate} expected but ${type} does not provide it.`,
-            sourceASTs(itfField, type)
-          ));
+            { nodes: sourceASTs(itfField, type) },
+          );
           continue;
         }
         // 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.
         if (this.validateHasType(itfField) && !isSubtype(itfField.type!, field.type!)) {
-          this.errors.push(new GraphQLError(
+          this.addError(
             `Interface field ${itfField.coordinate} expects type ${itfField.type} but ${field.coordinate} of type ${field.type} is not a proper subtype.`,
-            sourceASTs(itfField, field)
-          ));
+            { nodes: sourceASTs(itfField, field) },
+          );
         }
 
         for (const itfArg of itfField.arguments()) {
           const arg = field.argument(itfArg.name);
           if (!arg) {
-            this.errors.push(new GraphQLError(
+            this.addError(
               `Interface field argument ${itfArg.coordinate} expected but ${field.coordinate} does not provide it.`,
-              sourceASTs(itfArg, field)
-            ));
+              { nodes: sourceASTs(itfArg, field) },
+            );
             continue;
           }
           // Note that we could use contra-variance but as graphQL-js currently doesn't allow it, we mimic that.
           if (this.validateHasType(itfArg) && !sameType(itfArg.type!, arg.type!)) {
-            this.errors.push(new GraphQLError(
+            this.addError(
               `Interface field argument ${itfArg.coordinate} expects type ${itfArg.type} but ${arg.coordinate} is type ${arg.type}.`,
-              sourceASTs(itfArg, arg)
-            ));
+              { nodes: sourceASTs(itfArg, arg) },
+            );
           }
         }
 
@@ -215,10 +220,10 @@ class Validator {
             continue;
           }
           if (arg.isRequired()) {
-            this.errors.push(new GraphQLError(
+            this.addError(
               `Field ${field.coordinate} includes required argument ${arg.name} that is missing from the Interface field ${itfField.coordinate}.`,
-              sourceASTs(arg, itfField)
-            ));
+              { nodes: sourceASTs(arg, itfField) },
+            );
           }
         }
       }
@@ -227,12 +232,15 @@ class Validator {
       for (const itfOfItf of itf.interfaces()) {
         if (!type.implementsInterface(itfOfItf)) {
           if (itfOfItf === type) {
-            this.errors.push(new GraphQLError(`Type ${type} cannot implement ${itf} because it would create a circular reference.`, sourceASTs(type, itf)));
+            this.addError(
+              `Type ${type} cannot implement ${itf} because it would create a circular reference.`,
+              { nodes: sourceASTs(type, itf) },
+            );
           } else {
-            this.errors.push(new GraphQLError(
+            this.addError(
               `Type ${type} must implement ${itfOfItf} because it is implemented by ${itf}.`,
-              sourceASTs(type, itf, itfOfItf)
-            ));
+              { nodes: sourceASTs(type, itf, itfOfItf) },
+            );
           }
         }
       }
@@ -241,7 +249,7 @@ class Validator {
 
   private validateInputObjectType(type: InputObjectType) {
     if (!type.hasFields()) {
-      this.errors.push(new GraphQLError(`Input Object type ${type.name} must define one or more fields.`, type.sourceAST));
+      this.addError(`Input Object type ${type.name} must define one or more fields.`, { nodes: type.sourceAST });
     }
     for (const field of type.fields()) {
       this.validateName(field);
@@ -249,16 +257,16 @@ class Validator {
         continue;
       }
       if (field.isRequired() && field.isDeprecated()) {
-        this.errors.push(new GraphQLError(
+        this.addError(
           `Required input field ${field.coordinate} cannot be deprecated.`,
-          sourceASTs(field.appliedDirectivesOf('deprecated')[0], field)
-        ));
+          { nodes: sourceASTs(field.appliedDirectivesOf('deprecated')[0], field) },
+        );
       }
       if (field.defaultValue !== undefined && !isValidValue(field.defaultValue, field, new VariableDefinitions())) {
-        this.errors.push(new GraphQLError(
+        this.addError(
           `Invalid default value (got: ${valueToString(field.defaultValue)}) provided for input field ${field.coordinate} of type ${field.type}.`,
-          sourceASTs(field)
-        ));
+          { nodes: sourceASTs(field) },
+        );
       }
     }
   }
@@ -269,36 +277,36 @@ class Validator {
       return;
     }
     if (arg.isRequired() && arg.isDeprecated()) {
-      this.errors.push(new GraphQLError(
+      this.addError(
         `Required argument ${arg.coordinate} cannot be deprecated.`,
-        sourceASTs(arg.appliedDirectivesOf('deprecated')[0], arg)
-      ));
+        { nodes: sourceASTs(arg.appliedDirectivesOf('deprecated')[0], arg) },
+      );
     }
     if (arg.defaultValue !== undefined && !isValidValue(arg.defaultValue, arg, new VariableDefinitions())) {
-      this.errors.push(new GraphQLError(
+      this.addError(
         `Invalid default value (got: ${valueToString(arg.defaultValue)}) provided for argument ${arg.coordinate} of type ${arg.type}.`,
-        sourceASTs(arg)
-      ));
+        { nodes: sourceASTs(arg) },
+      );
     }
   }
 
   private validateUnionType(type: UnionType) {
     if (type.membersCount() === 0) {
-      this.errors.push(new GraphQLError(`Union type ${type.coordinate} must define one or more member types.`, type.sourceAST));
+      this.addError(`Union type ${type.coordinate} must define one or more member types.`, { nodes: type.sourceAST });
     }
   }
 
   private validateEnumType(type: EnumType) {
     if (type.values.length === 0) {
-      this.errors.push(new GraphQLError(`Enum type ${type.coordinate} must define one or more values.`, type.sourceAST));
+      this.addError(`Enum type ${type.coordinate} must define one or more values.`, { nodes: type.sourceAST });
     }
     for (const value of type.values) {
       this.validateName(value);
       if (value.name === 'true' || value.name === 'false' || value.name === 'null') {
-        this.errors.push(new GraphQLError(
+        this.addError(
           `Enum type ${type.coordinate} cannot include value: ${value}.`,
-          value.sourceAST
-        ));
+          { nodes: value.sourceAST },
+        );
       }
     }
   }
@@ -322,10 +330,10 @@ class Validator {
         const parentDesc = parent instanceof NamedSchemaElement
           ? parent.coordinate
           : 'schema';
-        this.errors.push(new GraphQLError(
+        this.addError(
           `Invalid value for "${argument.coordinate}" of type "${argument.type}" in application of "${definition.coordinate}" to "${parentDesc}".`,
-          sourceASTs(application, argument)
-        ));
+          { nodes: sourceASTs(application, argument) },
+        );
       }
     }
   }

package/src/validation/KnownTypeNamesInFederationRule.ts

@@ -40,7 +40,7 @@ export function KnownTypeNamesInFederationRule(
         context.reportError(
           new GraphQLError(
             `Unknown type "${typeName}".` + didYouMean(suggestedTypes),
-            node,
+            { nodes: node },
           ),
         );
       }

package/src/values.ts

@@ -34,6 +34,7 @@ import { didYouMean, suggestionList } from './suggestions';
 import { inspect } from 'util';
 import { sameType } from './types';
 import { assert, assertUnreachable } from './utils';
+import { ERRORS } from './error';
 
 // Per-GraphQL spec, max and value for an Int type.
 const MAX_INT = 2147483647;
@@ -189,7 +190,7 @@ function applyDefaultValues(value: any, type: InputType): any {
 
   if (value === null) {
     if (isNonNullType(type)) {
-      throw new GraphQLError(`Invalid null value for non-null type ${type} while computing default values`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Invalid null value for non-null type ${type} while computing default values`);
     }
     return null;
   }
@@ -208,7 +209,7 @@ function applyDefaultValues(value: any, type: InputType): any {
 
   if (isInputObjectType(type)) {
     if (typeof value !== 'object') {
-      throw new GraphQLError(`Expected value for type ${type} to be an object, but is ${typeof value}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Expected value for type ${type} to be an object, but is ${typeof value}.`);
     }
 
     const updated = Object.create(null);
@@ -221,7 +222,7 @@ function applyDefaultValues(value: any, type: InputType): any {
         if (field.defaultValue !== undefined) {
           updated[field.name] = applyDefaultValues(field.defaultValue, field.type);
         } else if (isNonNullType(field.type)) {
-          throw new GraphQLError(`Field "${field.name}" of required type ${type} was not provided.`);
+          throw ERRORS.INVALID_GRAPHQL.err(`Field "${field.name}" of required type ${type} was not provided.`);
         }
       } else {
         updated[field.name] = applyDefaultValues(fieldValue, field.type);
@@ -232,7 +233,7 @@ function applyDefaultValues(value: any, type: InputType): any {
     for (const fieldName of Object.keys(value)) {
       if (!type.field(fieldName)) {
         const suggestions = suggestionList(fieldName, type.fields().map(f => f.name));
-        throw new GraphQLError(`Field "${fieldName}" is not defined by type "${type}".` + didYouMean(suggestions));
+        throw ERRORS.INVALID_GRAPHQL.err(`Field "${fieldName}" is not defined by type "${type}".` + didYouMean(suggestions));
       }
     }
     return updated;
@@ -561,7 +562,7 @@ function isValidValueApplication(value: any, locationType: InputType, locationDe
 export function valueFromAST(node: ValueNode, expectedType: InputType): any {
   if (node.kind === Kind.NULL) {
     if (isNonNullType(expectedType)) {
-      throw new GraphQLError(`Invalid null value for non-null type "${expectedType}"`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Invalid null value for non-null type "${expectedType}"`);
     }
     return null;
   }
@@ -584,11 +585,11 @@ export function valueFromAST(node: ValueNode, expectedType: InputType): any {
 
   if (isIntType(expectedType)) {
     if (node.kind !== Kind.INT) {
-      throw new GraphQLError(`Int cannot represent non-integer value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Int cannot represent non-integer value ${print(node)}.`);
     }
     const i = parseInt(node.value, 10);
     if (i > MAX_INT || i < MIN_INT) {
-      throw new GraphQLError(`Int cannot represent non 32-bit signed integer value ${i}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Int cannot represent non 32-bit signed integer value ${i}.`);
     }
     return i;
   }
@@ -600,31 +601,31 @@ export function valueFromAST(node: ValueNode, expectedType: InputType): any {
     } else if (node.kind === Kind.FLOAT) {
       parsed = parseFloat(node.value);
     } else {
-      throw new GraphQLError(`Float can only represent integer or float value, but got a ${node.kind}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Float can only represent integer or float value, but got a ${node.kind}.`);
     }
     if (!isFinite(parsed)) {
-      throw new GraphQLError( `Float cannot represent non numeric value ${parsed}.`);
+      throw ERRORS.INVALID_GRAPHQL.err( `Float cannot represent non numeric value ${parsed}.`);
     }
     return parsed;
   }
 
   if (isBooleanType(expectedType)) {
     if (node.kind !== Kind.BOOLEAN) {
-      throw new GraphQLError(`Boolean cannot represent a non boolean value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Boolean cannot represent a non boolean value ${print(node)}.`);
     }
     return node.value;
   }
 
   if (isStringType(expectedType)) {
     if (node.kind !== Kind.STRING) {
-      throw new GraphQLError(`String cannot represent non string value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`String cannot represent non string value ${print(node)}.`);
     }
     return node.value;
   }
 
   if (isIDType(expectedType)) {
     if (node.kind !== Kind.STRING && node.kind !== Kind.INT) {
-      throw new GraphQLError(`ID cannot represent value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`ID cannot represent value ${print(node)}.`);
     }
     return node.value;
   }
@@ -635,14 +636,14 @@ export function valueFromAST(node: ValueNode, expectedType: InputType): any {
 
   if (isInputObjectType(expectedType)) {
     if (node.kind !== Kind.OBJECT) {
-      throw new GraphQLError(`Input Object Type ${expectedType} cannot represent non-object value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Input Object Type ${expectedType} cannot represent non-object value ${print(node)}.`);
     }
     const obj = Object.create(null);
     for (const f of node.fields) {
       const name = f.name.value;
       const field = expectedType.field(name);
       if (!field) {
-        throw new GraphQLError(`Unknown field "${name}" found in value for Input Object Type "${expectedType}".`);
+        throw ERRORS.INVALID_GRAPHQL.err(`Unknown field "${name}" found in value for Input Object Type "${expectedType}".`);
       }
       // TODO: as we recurse in sub-objects, we may get an error on a field value deep in the object
       // and the error will not be precise to where it happens. We could try to build the path to
@@ -654,10 +655,10 @@ export function valueFromAST(node: ValueNode, expectedType: InputType): any {
 
   if (isEnumType(expectedType)) {
     if (node.kind !== Kind.STRING && node.kind !== Kind.ENUM) {
-      throw new GraphQLError(`Enum Type ${expectedType} cannot represent value ${print(node)}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Enum Type ${expectedType} cannot represent value ${print(node)}.`);
     }
     if (!expectedType.value(node.value)) {
-      throw new GraphQLError(`Enum Type ${expectedType} has no value ${node.value}.`);
+      throw ERRORS.INVALID_GRAPHQL.err(`Enum Type ${expectedType} has no value ${node.value}.`);
     }
     return node.value;
   }
@@ -699,7 +700,7 @@ export function argumentsFromAST(
       const name = argNode.name.value;
       const expectedType = argsDefiner.argument(name)?.type;
       if (!expectedType) {
-        throw new GraphQLError(
+        throw ERRORS.INVALID_GRAPHQL.err(
           `Unknown argument "${name}" found in value: ${context} has no argument named "${name}"`
         );
       }
@@ -707,7 +708,7 @@ export function argumentsFromAST(
         values[name] = valueFromAST(argNode.value, expectedType);
       } catch (e) {
         if (e instanceof GraphQLError) {
-          throw new GraphQLError(`Invalid value for argument ${name}: ${e.message}`);
+          throw ERRORS.INVALID_GRAPHQL.err(`Invalid value for argument ${name}: ${e.message}`);
         }
         throw e;
       }