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

package/src/__tests__/values.test.ts

@@ -1,8 +1,11 @@
 import {
   Schema,
-} from '../../dist/definitions';
-import { buildSchema } from '../../dist/buildSchema';
-import { parseOperation } from '../../dist/operations';
+} from '../definitions';
+import { buildSchema } from '../buildSchema';
+import { parseOperation } from '../operations';
+import { buildForErrors } from './subgraphValidation.test';
+import gql from 'graphql-tag';
+import { printSchema } from '../print';
 
 function parseSchema(schema: string): Schema {
   try {
@@ -66,3 +69,312 @@ test('handles non-list value for list argument (as singleton)', () => {
     }
   `);
 });
+
+describe('default value validation', () => {
+  it('errors on invalid default value in field argument', () => {
+    const doc = gql`
+      type Query {
+        f(a: Int = "foo"): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: "foo") provided for argument Query.f(a:) of type Int.'
+    ]]);
+  });
+
+  it('errors on invalid default value in directive argument', () => {
+    const doc = gql`
+      type Query {
+        f: Int
+      }
+
+      directive @myDirective(a: Int = "foo") on FIELD
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: "foo") provided for argument @myDirective(a:) of type Int.'
+    ]]);
+  });
+
+  it('errors on invalid default value in input field', () => {
+    const doc = gql`
+      input I {
+        x: Int = "foo"
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: "foo") provided for input field I.x of type Int.'
+    ]]);
+  });
+
+  it('errors on invalid default value for existing input field', () => {
+    const doc = gql`
+      type Query {
+        f(i: I = { x: 2, y: "3" }): Int
+      }
+
+      input I {
+        x: Int
+        y: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: {x: 2, y: "3"}) provided for argument Query.f(i:) of type I.'
+    ]]);
+  });
+
+  it('errors on default value containing unexpected input fields', () => {
+    const doc = gql`
+      type Query {
+        f(i: I = { x: 1, y: 2, z: 3 }): Int
+      }
+
+      input I {
+        x: Int
+        y: Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: {x: 1, y: 2, z: 3}) provided for argument Query.f(i:) of type I.'
+    ]]);
+  });
+
+  it('errors on default value being unknown enum value', () => {
+    const doc = gql`
+      type Query {
+        f(e: E = THREE): Int
+      }
+
+      enum E {
+        ONE
+        TWO
+      }
+    `;
+
+    // Note that it is slightly imperfect that the error shows the value as a "string" but is the result
+    // of enum values being encoded by string value internally (and while, when a value type-check correctly,
+    // we can use the type to display enum values properly, this is exactly a case where the value is not
+    // correctly type-checked, so we currently don't have a good way to figure out it's an enum when we display
+    // it in the error message). We could fix this someday if we change to using a specific class/object for
+    // enum values internally (though this might have backward compatbility constraints), but in the meantime,
+    // it's unlikely to trip users too much. 
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: "THREE") provided for argument Query.f(e:) of type E.'
+    ]]);
+  });
+
+  it('errors on default value being unknown enum value (as string)', () => {
+    const doc = gql`
+      type Query {
+        f(e: E = "TWOO"): Int
+      }
+
+      enum E {
+        ONE
+        TWO
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: "TWOO") provided for argument Query.f(e:) of type E.'
+    ]]);
+  });
+
+  it('accepts default value enum value as string, if a valid enum value', () => {
+    // Please note that this test show we accept strings for enum even though the GraphQL spec kind
+    // of say we shouldn't. But the graphQL spec also doesn't really do default value validation,
+    // which be believe is just wrong, and as a consequence we've seen customer schema with string-for-enum
+    // in default values, and it doesn't sound very harmfull to allow it (the spec even admits that some
+    // transport may have to deal with enums as string anyway), so we prefer having that allowance in
+    // federation (if this ever become a huge issue for some users, we could imagine to add a "strict"
+    // more that start refusing this).
+    const doc = gql`
+      type Query {
+        f(e: E = "TWO"): Int
+      }
+
+      enum E {
+        ONE
+        TWO
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts any value for a custom scalar in field agument', () => {
+    const doc = gql`
+      type Query {
+        f(i: Scalar = { x: 2, y: "3" }): Int
+      }
+
+      scalar Scalar
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts any value for a custom scalar in directive agument', () => {
+    const doc = gql`
+      type Query {
+        f: Int
+      }
+
+      directive @myDirective(i: Scalar = { x: 2, y: "3" }) on FIELD
+      scalar Scalar
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts any value for a custom scalar in an input field', () => {
+    const doc = gql`
+      input I {
+        x: Scalar = { z: { a: 4} }
+      }
+
+      scalar Scalar
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts default value coercible to list for a list type', () => {
+    const doc = gql`
+      type Query {
+        f(x: [String] = "foo"): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts default value coercible to list for a list type through multiple coercions', () => {
+    const doc = gql`
+      type Query {
+        f(x: [[[String]!]]! = "foo"): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('errors on default value no coercible to list for a list type through multiple coercions', () => {
+    const doc = gql`
+      type Query {
+        f(x: [[[String]!]]! = 2): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: 2) provided for argument Query.f(x:) of type [[[String]!]]!.'
+    ]]);
+  });
+
+  it('accepts default value coercible to its type but needing multiple/nested coercions', () => {
+    const doc = gql`
+      type Query {
+        f(x: I = { j: {x: 1, z: "Foo"} }): Int
+      }
+
+      input I {
+        j: [J]
+      }
+
+      input J {
+        x: ID
+        y: ID
+        z: ID
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('accepts default values that, if actually coerced, woudl result in infinite loops', () => {
+    // This example is stolen from this comment: https://github.com/graphql/graphql-spec/pull/793#issuecomment-738736539
+    // It essentially show that while, as the other tests of this file show, we 1) validate default value against
+    // their type and 2) ensures default values coercible to said type don't fail such validation, we also do
+    // _not_ do the actual coercion of those values, which in this example would lead to an infinite loop.
+    const doc = gql`
+      input A {
+        b: B = {}
+      }
+
+      input B {
+        a: A = {}
+      }
+
+      type Query {
+        q(a: A = {}): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+
+  it('errors on null default value for non-nullable input', () => {
+    const doc = gql`
+      type Query {
+        f(i: Int! = null): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toStrictEqual([[
+      'INVALID_GRAPHQL',
+      '[S] Invalid default value (got: null) provided for argument Query.f(i:) of type Int!.'
+    ]]);
+  });
+
+  it('Accepts null default value for nullable input', () => {
+    const doc = gql`
+      type Query {
+        f(i: Int = null): Int
+      }
+    `;
+
+    expect(buildForErrors(doc)).toBeUndefined();
+  });
+});
+
+describe('values printing', () => {
+  it('prints enums value correctly within multiple lists', () => {
+    const sdl = `
+      type Query {
+        f(a: [[[E]!]!] = [[[FOO], [BAR]]]): Int
+      }
+
+      enum E {
+        FOO
+        BAR
+      }
+    `
+    expect(printSchema(parseSchema(sdl))).toMatchString(sdl);
+  })
+
+  it('prints enums value when its coercible to list through multiple coercions', () => {
+    const sdl = `
+      type Query {
+        f(a: [[[E]!]!] = FOO): Int
+      }
+
+      enum E {
+        FOO
+        BAR
+      }
+    `
+    expect(printSchema(parseSchema(sdl))).toMatchString(sdl);
+  })
+});

package/src/buildSchema.ts

@@ -46,7 +46,9 @@ import {
   UnionType,
   InputObjectType,
   EnumType,
-  Extension
+  Extension,
+  ErrGraphQLValidationFailed,
+  errorCauses,
 } from "./definitions";
 
 function buildValue(value?: ValueNode): any {
@@ -66,6 +68,7 @@ export function buildSchemaFromAST(
   documentNode: DocumentNode,
   options?: BuildSchemaOptions,
 ): Schema {
+  const errors: GraphQLError[] = [];
   const schema = new Schema(options?.blueprint);
   // We do a first pass to add all empty types and directives definition. This ensure any reference on one of
   // those can be resolved in the 2nd pass, regardless of the order of the definitions in the AST.
@@ -77,29 +80,30 @@ export function buildSchemaFromAST(
   // populated (and at this point, we don't really know the name of the `@core` directive since it can be renamed, so
   // we just handle all directives).
   for (const directiveDefinitionNode of directiveDefinitions) {
-    buildDirectiveDefinitionInner(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!);
+    buildDirectiveDefinitionInner(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!, errors);
   }
   for (const schemaDefinition of schemaDefinitions) {
-    buildSchemaDefinitionInner(schemaDefinition, schema.schemaDefinition);
+    buildSchemaDefinitionInner(schemaDefinition, schema.schemaDefinition, errors);
   }
   for (const schemaExtension of schemaExtensions) {
-    buildSchemaDefinitionInner(schemaExtension, schema.schemaDefinition, schema.schemaDefinition.newExtension());
+    buildSchemaDefinitionInner(schemaExtension, schema.schemaDefinition, errors, schema.schemaDefinition.newExtension());
   }
 
-  schema.blueprint.onDirectiveDefinitionAndSchemaParsed(schema);
+  errors.push(...schema.blueprint.onDirectiveDefinitionAndSchemaParsed(schema));
 
   for (const definitionNode of documentNode.definitions) {
     switch (definitionNode.kind) {
       case 'OperationDefinition':
       case 'FragmentDefinition':
-        throw new GraphQLError("Invalid executable definition found while building schema", definitionNode);
+        errors.push(new GraphQLError("Invalid executable definition found while building schema", definitionNode));
+        continue;
       case 'ScalarTypeDefinition':
       case 'ObjectTypeDefinition':
       case 'InterfaceTypeDefinition':
       case 'UnionTypeDefinition':
       case 'EnumTypeDefinition':
       case 'InputObjectTypeDefinition':
-        buildNamedTypeInner(definitionNode, schema.type(definitionNode.name.value)!, schema.blueprint);
+        buildNamedTypeInner(definitionNode, schema.type(definitionNode.name.value)!, schema.blueprint, errors);
         break;
       case 'ScalarTypeExtension':
       case 'ObjectTypeExtension':
@@ -110,11 +114,20 @@ export function buildSchemaFromAST(
         const toExtend = schema.type(definitionNode.name.value)!;
         const extension = toExtend.newExtension();
         extension.sourceAST = definitionNode;
-        buildNamedTypeInner(definitionNode, toExtend, schema.blueprint, extension);
+        buildNamedTypeInner(definitionNode, toExtend, schema.blueprint, errors, extension);
         break;
     }
   }
 
+  // Note: we could try calling `schema.validate()` regardless of errors building the schema and merge the resulting
+  // errors, and there is some subset of cases where this be a tad more convenient (as the user would get all the errors
+  // at once), but in most cases a bunch of the errors thrown by `schema.validate()` would actually be consequences of
+  // the schema not be properly built in the first place and those errors would be confusing to the user. And avoiding
+  // confusing users probably trumps a rare minor convenience.
+  if (errors.length > 0) {
+    throw ErrGraphQLValidationFailed(errors);
+  }
+
   if (options?.validate ?? true) {
     schema.validate();
   }
@@ -187,21 +200,24 @@ function getReferencedType(node: NamedTypeNode, schema: Schema): NamedType {
   return type;
 }
 
-function withNodeAttachedToError(operation: () => void, node: ASTNode) {
+function withNodeAttachedToError(operation: () => void, node: ASTNode, errors: GraphQLError[]) {
   try {
     operation();
   } catch (e) {
-    if (e instanceof GraphQLError) {
-      const allNodes: ASTNode | ASTNode[] = e.nodes ? [node, ...e.nodes] : node;
-      throw new GraphQLError(
-        e.message,
-        allNodes,
-        e.source,
-        e.positions,
-        e.path,
-        e,
-        e.extensions
-      );
+    const causes = errorCauses(e);
+    if (causes) {
+      for (const cause of causes) {
+        const allNodes: ASTNode | ASTNode[] = cause.nodes ? [node, ...cause.nodes] : node;
+        errors.push(new GraphQLError(
+          cause.message,
+          allNodes,
+          cause.source,
+          cause.positions,
+          cause.path,
+          cause,
+          cause.extensions
+        ));
+      }
     } else {
       throw e;
     }
@@ -211,31 +227,39 @@ function withNodeAttachedToError(operation: () => void, node: ASTNode) {
 function buildSchemaDefinitionInner(
   schemaNode: SchemaDefinitionNode | SchemaExtensionNode,
   schemaDefinition: SchemaDefinition,
+  errors: GraphQLError[],
   extension?: Extension<SchemaDefinition>
 ) {
   for (const opTypeNode of schemaNode.operationTypes ?? []) {
     withNodeAttachedToError(
       () => schemaDefinition.setRoot(opTypeNode.operation, opTypeNode.type.name.value).setOfExtension(extension),
-      opTypeNode);
+      opTypeNode,
+      errors,
+    );
   }
   schemaDefinition.sourceAST = schemaNode;
   if ('description' in schemaNode) {
     schemaDefinition.description = schemaNode.description?.value;
   }
-  buildAppliedDirectives(schemaNode, schemaDefinition, extension);
+  buildAppliedDirectives(schemaNode, schemaDefinition, errors, extension);
 }
 
 function buildAppliedDirectives(
   elementNode: NodeWithDirectives,
   element: SchemaElement<any, any>,
+  errors: GraphQLError[],
   extension?: Extension<any>
 ) {
   for (const directive of elementNode.directives ?? []) {
-    withNodeAttachedToError(() => {
-      const d = element.applyDirective(directive.name.value, buildArgs(directive));
-      d.setOfExtension(extension);
-      d.sourceAST = directive;
-    }, directive);
+    withNodeAttachedToError(
+      () => {
+        const d = element.applyDirective(directive.name.value, buildArgs(directive));
+        d.setOfExtension(extension);
+        d.sourceAST = directive;
+      },
+      directive,
+      errors,
+    );
   }
 }
 
@@ -251,6 +275,7 @@ function buildNamedTypeInner(
   definitionNode: DefinitionNode & NodeWithDirectives & NodeWithDescription,
   type: NamedType,
   blueprint: SchemaBlueprint,
+  errors: GraphQLError[],
   extension?: Extension<any>,
 ) {
   switch (definitionNode.kind) {
@@ -265,18 +290,20 @@ function buildNamedTypeInner(
         }
         const field = fieldBasedType.addField(fieldNode.name.value);
         field.setOfExtension(extension);
-        buildFieldDefinitionInner(fieldNode, field);
+        buildFieldDefinitionInner(fieldNode, field, errors);
       }
       for (const itfNode of definitionNode.interfaces ?? []) {
         withNodeAttachedToError(
           () => {
             const itfName = itfNode.name.value;
             if (fieldBasedType.implementsInterface(itfName)) {
-              throw new GraphQLError(`Type ${type} can only implement ${itfName} once.`);
+              throw new GraphQLError(`Type "${type}" can only implement "${itfName}" once.`);
             }
             fieldBasedType.addImplementedInterface(itfName).setOfExtension(extension);
           },
-          itfNode);
+          itfNode,
+          errors,
+        );
       }
       break;
     case 'UnionTypeDefinition':
@@ -287,11 +314,13 @@ function buildNamedTypeInner(
           () => {
             const name = namedType.name.value;
             if (unionType.hasTypeMember(name)) {
-              throw new GraphQLError(`Union type ${unionType} can only include type ${name} once.`);
+              throw new GraphQLError(`Union type "${unionType}" can only include type "${name}" once.`);
             }
             unionType.addType(name).setOfExtension(extension);
           },
-          namedType);
+          namedType,
+          errors,
+        );
       }
       break;
     case 'EnumTypeDefinition':
@@ -303,7 +332,7 @@ function buildNamedTypeInner(
           v.description = enumVal.description.value;
         }
         v.setOfExtension(extension);
-        buildAppliedDirectives(enumVal, v);
+        buildAppliedDirectives(enumVal, v, errors);
       }
       break;
     case 'InputObjectTypeDefinition':
@@ -312,41 +341,47 @@ function buildNamedTypeInner(
       for (const fieldNode of definitionNode.fields ?? []) {
         const field = inputObjectType.addField(fieldNode.name.value);
         field.setOfExtension(extension);
-        buildInputFieldDefinitionInner(fieldNode, field);
+        buildInputFieldDefinitionInner(fieldNode, field, errors);
       }
       break;
   }
-  buildAppliedDirectives(definitionNode, type, extension);
+  buildAppliedDirectives(definitionNode, type, errors, extension);
   if (definitionNode.description) {
     type.description = definitionNode.description.value;
   }
   type.sourceAST = definitionNode;
 }
 
-function buildFieldDefinitionInner(fieldNode: FieldDefinitionNode, field: FieldDefinition<any>) {
+function buildFieldDefinitionInner(
+  fieldNode: FieldDefinitionNode,
+  field: FieldDefinition<any>,
+  errors: GraphQLError[],
+) {
   const type = buildTypeReferenceFromAST(fieldNode.type, field.schema());
-  field.type = ensureOutputType(type, field.coordinate, fieldNode);
+  field.type = validateOutputType(type, field.coordinate, fieldNode, errors);
   for (const inputValueDef of fieldNode.arguments ?? []) {
-    buildArgumentDefinitionInner(inputValueDef, field.addArgument(inputValueDef.name.value));
+    buildArgumentDefinitionInner(inputValueDef, field.addArgument(inputValueDef.name.value), errors);
   }
-  buildAppliedDirectives(fieldNode, field);
+  buildAppliedDirectives(fieldNode, field, errors);
   field.description = fieldNode.description?.value;
   field.sourceAST = fieldNode;
 }
 
-function ensureOutputType(type: Type, what: string, node: ASTNode): OutputType {
+function validateOutputType(type: Type, what: string, node: ASTNode, errors: GraphQLError[]): OutputType | undefined {
   if (isOutputType(type)) {
     return type;
   } else {
-    throw new GraphQLError(`The type of ${what} must be Output Type but got: ${type}, a ${type.kind}.`, node);
+    errors.push(new GraphQLError(`The type of "${what}" must be Output Type but got "${type}", a ${type.kind}.`, node));
+    return undefined;
   }
 }
 
-function ensureInputType(type: Type, what: string, node: ASTNode): InputType {
+function validateInputType(type: Type, what: string, node: ASTNode, errors: GraphQLError[]): InputType | undefined {
   if (isInputType(type)) {
     return type;
   } else {
-    throw new GraphQLError(`The type of ${what} must be Input Type but got: ${type}, a ${type.kind}.`, node);
+    errors.push(new GraphQLError(`The type of "${what}" must be Input Type but got "${type}", a ${type.kind}.`, node));
+    return undefined;
   }
 }
 
@@ -369,27 +404,39 @@ function buildTypeReferenceFromAST(typeNode: TypeNode, schema: Schema): Type {
   }
 }
 
-function buildArgumentDefinitionInner(inputNode: InputValueDefinitionNode, arg: ArgumentDefinition<any>) {
+function buildArgumentDefinitionInner(
+  inputNode: InputValueDefinitionNode,
+  arg: ArgumentDefinition<any>,
+  errors: GraphQLError[],
+) {
   const type = buildTypeReferenceFromAST(inputNode.type, arg.schema());
-  arg.type = ensureInputType(type, arg.coordinate, inputNode);
+  arg.type = validateInputType(type, arg.coordinate, inputNode, errors);
   arg.defaultValue = buildValue(inputNode.defaultValue);
-  buildAppliedDirectives(inputNode, arg);
+  buildAppliedDirectives(inputNode, arg, errors);
   arg.description = inputNode.description?.value;
   arg.sourceAST = inputNode;
 }
 
-function buildInputFieldDefinitionInner(fieldNode: InputValueDefinitionNode, field: InputFieldDefinition) {
+function buildInputFieldDefinitionInner(
+  fieldNode: InputValueDefinitionNode,
+  field: InputFieldDefinition,
+  errors: GraphQLError[],
+) {
   const type = buildTypeReferenceFromAST(fieldNode.type, field.schema());
-  field.type = ensureInputType(type, field.coordinate, fieldNode);
+  field.type = validateInputType(type, field.coordinate, fieldNode, errors);
   field.defaultValue = buildValue(fieldNode.defaultValue);
-  buildAppliedDirectives(fieldNode, field);
+  buildAppliedDirectives(fieldNode, field, errors);
   field.description = fieldNode.description?.value;
   field.sourceAST = fieldNode;
 }
 
-function buildDirectiveDefinitionInner(directiveNode: DirectiveDefinitionNode, directive: DirectiveDefinition) {
+function buildDirectiveDefinitionInner(
+  directiveNode: DirectiveDefinitionNode,
+  directive: DirectiveDefinition,
+  errors: GraphQLError[],
+) {
   for (const inputValueDef of directiveNode.arguments ?? []) {
-    buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value));
+    buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value), errors);
   }
   directive.repeatable = directiveNode.repeatable;
   const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocation);