@apollo/federation-internals 2.0.0-preview.8 → 2.0.1

package/src/__tests__/subgraphValidation.test.ts

@@ -1,12 +1,15 @@
 import { DocumentNode } from 'graphql';
 import gql from 'graphql-tag';
+import { Subgraph } from '..';
 import { errorCauses } from '../definitions';
 import { asFed2SubgraphDocument, buildSubgraph } from "../federation"
+import { defaultPrintOptions, printSchema } from '../print';
+import './matchers';
 
 // Builds the provided subgraph (using name 'S' for the subgraph) and, if the
 // subgraph is invalid/has errors, return those errors as a list of [code, message].
 // If the subgraph is valid, return undefined.
-function buildForErrors(
+export function buildForErrors(
   subgraphDefs: DocumentNode,
   options?: {
     subgraphName?: string,
@@ -523,3 +526,356 @@ describe('custom error message for misnamed directives', () => {
     ]);
   });
 });
+
+function buildAndValidate(doc: DocumentNode): Subgraph {
+  const name = 'S';
+  return buildSubgraph(name, `http://${name}`, doc).validate();
+}
+
+describe('@core/@link handling', () => {
+  const expectedFullSchema = `
+    schema
+      @link(url: "https://specs.apollo.dev/link/v1.0")
+      @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+    {
+      query: Query
+    }
+
+    directive @link(url: String, as: String, for: link__Purpose, import: [link__Import]) repeatable on SCHEMA
+
+    directive @key(fields: federation__FieldSet!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+
+    directive @federation__requires(fields: federation__FieldSet!) on FIELD_DEFINITION
+
+    directive @federation__provides(fields: federation__FieldSet!) on FIELD_DEFINITION
+
+    directive @federation__external(reason: String) on OBJECT | FIELD_DEFINITION
+
+    directive @federation__tag(name: String!) repeatable on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+    directive @federation__extends on OBJECT | INTERFACE
+
+    directive @federation__shareable on OBJECT | FIELD_DEFINITION
+
+    directive @federation__inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+    directive @federation__override(from: String!) on FIELD_DEFINITION
+
+    type T
+      @key(fields: "k")
+    {
+      k: ID!
+    }
+
+    enum link__Purpose {
+      """
+      \`SECURITY\` features provide metadata necessary to securely resolve fields.
+      """
+      SECURITY
+
+      """
+      \`EXECUTION\` features provide metadata necessary for operation execution.
+      """
+      EXECUTION
+    }
+
+    scalar link__Import
+
+    scalar federation__FieldSet
+
+    scalar _Any
+
+    type _Service {
+      sdl: String
+    }
+
+    union _Entity = T
+
+    type Query {
+      _entities(representations: [_Any!]!): [_Entity]!
+      _service: _Service!
+    }
+  `
+  const validateFullSchema = (subgraph: Subgraph) => {
+    // Note: we merge types and extensions to avoid having to care whether the @link are on a schema definition or schema extension
+    // as 1) this will vary (we add them to extensions in our test, but when auto-added, they are added to the schema definition)
+    // and 2) it doesn't matter in practice, it's valid in all cases.
+    expect(printSchema(subgraph.schema, { ...defaultPrintOptions, mergeTypesAndExtensions: true})).toMatchString(expectedFullSchema);
+  }
+
+  it('expands everything if only the federation spec is linked', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+    `;
+
+    validateFullSchema(buildAndValidate(doc));
+  });
+
+  it('expands definitions if both the federation spec and link spec are linked', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/link/v1.0")
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+    `;
+
+    validateFullSchema(buildAndValidate(doc));
+  });
+
+  it('is valid if a schema is complete from the get-go', () => {
+    validateFullSchema(buildAndValidate(gql(expectedFullSchema)));
+  });
+
+  it('expands missing definitions when some are partially provided', () => {
+    const docs = [
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/link/v1.0")
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        directive @key(fields: federation__FieldSet!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+
+        scalar federation__FieldSet
+
+        scalar link__Import
+      `,
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/link/v1.0")
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        scalar link__Import
+      `,
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        scalar link__Import
+      `,
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        directive @federation__external(reason: String) on OBJECT | FIELD_DEFINITION
+      `,
+    ];
+
+    // Note that we cannot use `validateFullSchema` as-is for those examples because the order or directive is going
+    // to be different. But that's ok, we mostly care that the validation doesn't throw since validation ultimately
+    // calls the graphQL-js validation, so we can be somewhat sure that if something necessary wasn't expanded
+    // properly, we would have an issue. The main reason we did validate the full schema in prior tests is
+    // so we had at least one full example of a subgraph expansion in the tests.
+    docs.forEach((doc) => buildAndValidate(doc));
+  });
+
+  it('allows known directives with incomplete but compatible definitions', () => {
+    const docs = [
+      // @key has a `resolvable` argument in its full definition, but it is optional.
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/link/v1.0")
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        directive @key(fields: federation__FieldSet!) repeatable on OBJECT | INTERFACE
+
+        scalar federation__FieldSet
+      `,
+      // @inacessible can be put in a bunch of locations, but you're welcome to restrict yourself to just fields.
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/link/v1.0")
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@inaccessible"])
+
+        type T {
+          k: ID! @inaccessible
+        }
+
+        directive @inaccessible on FIELD_DEFINITION
+      `,
+      // @key is repeatable, but you're welcome to restrict yourself to never repeating it.
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        directive @key(fields: federation__FieldSet!, resolvable: Boolean = true) on OBJECT | INTERFACE
+
+        scalar federation__FieldSet
+      `,
+      // @key `resolvable` argument is optional, but you're welcome to force users to always provide it.
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k", resolvable: true) {
+          k: ID!
+        }
+
+        directive @key(fields: federation__FieldSet!, resolvable: Boolean!) repeatable on OBJECT | INTERFACE
+
+        scalar federation__FieldSet
+      `,
+      // @link `url` argument is allowed to be `null` now, but it used not too, so making sure we still
+      // accept definition where it's mandatory.
+      gql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/link/v1.0")
+          @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+        type T @key(fields: "k") {
+          k: ID!
+        }
+
+        directive @link(url: String!, as: String, for: link__Purpose, import: [link__Import]) repeatable on SCHEMA
+
+        scalar link__Import
+        scalar link__Purpose
+      `,
+    ];
+
+    // Like above, we really only care that the examples validate.
+    docs.forEach((doc) => buildAndValidate(doc));
+  });
+
+  it('errors on invalid known directive location', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      directive @federation__external(reason: String) on OBJECT | FIELD_DEFINITION | SCHEMA
+    `;
+
+    // @external is not allowed on 'schema' and likely never will.
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+        'DIRECTIVE_DEFINITION_INVALID',
+        '[S] Invalid definition for directive "@federation__external": "@federation__external" should have locations OBJECT, FIELD_DEFINITION, but found (non-subset) OBJECT, FIELD_DEFINITION, SCHEMA',
+    ]]);
+  });
+
+  it('errors on invalid non-repeatable directive marked repeateable', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      directive @federation__external repeatable on OBJECT | FIELD_DEFINITION
+    `;
+
+    // @external is not repeatable (and has no reason to be since it has no arguments).
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+      'DIRECTIVE_DEFINITION_INVALID',
+      '[S] Invalid definition for directive "@federation__external": "@federation__external" should not be repeatable',
+    ]]);
+  });
+
+  it('errors on unknown argument of known directive', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      directive @federation__external(foo: Int) on OBJECT | FIELD_DEFINITION
+    `;
+
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+      'DIRECTIVE_DEFINITION_INVALID',
+      '[S] Invalid definition for directive "@federation__external": unknown/unsupported argument "foo"',
+    ]]);
+  });
+
+  it('errors on invalid type for a known argument', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      directive @key(fields: String!, resolvable: String) repeatable on OBJECT | INTERFACE
+    `;
+
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+      'DIRECTIVE_DEFINITION_INVALID',
+      '[S] Invalid definition for directive "@key": argument "resolvable" should have type "Boolean" but found type "String"',
+    ]]);
+  });
+
+  it('errors on a required argument defined as optional', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      directive @key(fields: federation__FieldSet, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+
+      scalar federation__FieldSet
+    `;
+
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+      'DIRECTIVE_DEFINITION_INVALID',
+      '[S] Invalid definition for directive "@key": argument "fields" should have type "federation__FieldSet!" but found type "federation__FieldSet"',
+    ]]);
+  });
+
+  it('allows any (non-scalar) type in redefinition when expected type is a scalar', () => {
+    const doc = gql`
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key"])
+
+      type T @key(fields: "k") {
+        k: ID!
+      }
+
+      # 'fields' should be of type 'federation_FieldSet!', but ensure we allow 'String!' alternatively.
+      directive @key(fields: String!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+    `;
+
+    // Just making sure this don't error out.
+    buildAndValidate(doc);
+  });
+});

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

@@ -89,7 +89,7 @@ export function buildSchemaFromAST(
     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) {