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

package/src/__tests__/subgraphValidation.test.ts

@@ -9,7 +9,7 @@ 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,
@@ -557,7 +557,7 @@ describe('@core/@link handling', () => {
 
     directive @federation__shareable on OBJECT | FIELD_DEFINITION
 
-    directive @federation__inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION
+    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
 
@@ -593,7 +593,7 @@ describe('@core/@link handling', () => {
 
     type Query {
       _entities(representations: [_Any!]!): [_Entity]!
-      _service: _Service
+      _service: _Service!
     }
   `
   const validateFullSchema = (subgraph: Subgraph) => {
@@ -833,12 +833,12 @@ describe('@core/@link handling', () => {
         k: ID!
       }
 
-      directive @key(fields: Int!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+      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 "fields" should have type "federation__FieldSet!" but found type "Int!"',
+      '[S] Invalid definition for directive "@key": argument "resolvable" should have type "Boolean" but found type "String"',
     ]]);
   });
 
@@ -861,4 +861,21 @@ describe('@core/@link handling', () => {
       '[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/coreSpec.ts

@@ -1,6 +1,6 @@
 import { ASTNode, DirectiveLocation, GraphQLError, StringValueNode } from "graphql";
 import { URL } from "url";
-import { CoreFeature, Directive, DirectiveDefinition, EnumType, ErrGraphQLValidationFailed, InputType, ListType, NamedType, NonNullType, ScalarType, Schema, SchemaDefinition } from "./definitions";
+import { CoreFeature, Directive, DirectiveDefinition, EnumType, ErrGraphQLAPISchemaValidationFailed, ErrGraphQLValidationFailed, InputType, ListType, NamedType, NonNullType, ScalarType, Schema, SchemaDefinition, SchemaElement } from "./definitions";
 import { sameType } from "./types";
 import { err } from '@apollo/core-schema';
 import { assert } from './utils';
@@ -706,20 +706,74 @@ export const LINK_VERSIONS = new FeatureDefinitions<CoreSpecDefinition>(linkIden
 registerKnownFeature(CORE_VERSIONS);
 registerKnownFeature(LINK_VERSIONS);
 
-export function removeFeatureElements(schema: Schema, feature: CoreFeature) {
-  // Removing directives first, so that when we remove types, the checks that there is no references don't fail due a directive of a the feature
-  // actually using the type.
-  const featureDirectives = schema.directives().filter(d => feature.isFeatureDefinition(d));
-  featureDirectives.forEach(d => d.remove().forEach(application => application.remove()));
-
-  const featureTypes = schema.types().filter(t => feature.isFeatureDefinition(t));
-  featureTypes.forEach(type => {
-    const references = type.remove();
-    if (references.length > 0) {
-      throw new GraphQLError(
-        `Cannot remove elements of feature ${feature} as feature type ${type} is referenced by elements: ${references.join(', ')}`,
-        references.map(r => r.sourceAST).filter(n => n !== undefined) as ASTNode[]
-      );
+export function removeAllCoreFeatures(schema: Schema) {
+  // Gather a list of core features up front, since we can't fetch them during
+  // removal. (Also note that core being a feature itself, this will remove core
+  // itself and mark the schema as 'not core').
+  const coreFeatures = [...(schema.coreFeatures?.allFeatures() ?? [])];
+
+  // Remove all feature elements, keeping track of any type references found
+  // along the way.
+  const typeReferences: {
+    feature: CoreFeature;
+    type: NamedType;
+    references: SchemaElement<any, any>[];
+  }[] = [];
+  for (const feature of coreFeatures) {
+    // Remove feature directive definitions and their applications.
+    const featureDirectiveDefs = schema.directives()
+      .filter(d => feature.isFeatureDefinition(d));
+    featureDirectiveDefs.forEach(def =>
+      def.remove().forEach(application => application.remove())
+    );
+
+    // Remove feature types.
+    const featureTypes = schema.types()
+      .filter(t => feature.isFeatureDefinition(t));
+    featureTypes.forEach(type => {
+      const references = type.remove();
+      if (references.length > 0) {
+        typeReferences.push({
+          feature,
+          type,
+          references,
+        });
       }
-  });
+    });
+  }
+
+  // Now that we're finished with removals, for any referencers encountered,
+  // check whether they're still attached to the schema (and fail if they are).
+  //
+  // We wait for after all removals are done, since it means we don't have to
+  // worry about the ordering of removals (e.g. if one feature element refers
+  // to a different feature's element) or any circular references.
+  //
+  // Note that we fail for ALL type referencers, regardless of whether removing
+  // the type necessitates removal of the type referencer. E.g. even if some
+  // non-core object type were to implement some core feature interface type, we
+  // would still require removal of the non-core object type. Users don't have
+  // to enact this removal by removing the object type from their supergraph
+  // schema though; they could also just mark it @inaccessible (since this
+  // function is called after removeInaccessibleElements()).
+  //
+  // In the future, we could potentially relax this validation once we determine
+  // the appropriate semantics. (This validation has already been relaxed for
+  // directive applications, since feature directive definition removal does not
+  // necessitate removal of elements with directive applications.)
+  const errors: GraphQLError[] = [];
+  for (const { feature, type, references } of typeReferences) {
+    const referencesInSchema = references.filter(r => r.isAttached());
+    if (referencesInSchema.length > 0) {
+      errors.push(new GraphQLError(
+        `Cannot remove elements of feature ${feature} as feature type ${type}` +
+        ` is referenced by elements: ${referencesInSchema.join(', ')}`,
+        references.map(r => r.sourceAST)
+          .filter(n => n !== undefined) as ASTNode[]
+      ));
+    }
+  }
+  if (errors.length > 0) {
+    throw ErrGraphQLAPISchemaValidationFailed(errors);
+  }
 }