@apollo/federation-internals 2.0.2-alpha.0 → 2.0.2-alpha.1

package/src/__tests__/operations.test.ts

@@ -2,7 +2,7 @@ import {
   Schema,
 } from '../../dist/definitions';
 import { buildSchema } from '../../dist/buildSchema';
-import { parseOperation } from '../../dist/operations';
+import { Field, FieldSelection, parseOperation, SelectionSet } from '../../dist/operations';
 import './matchers';
 
 function parseSchema(schema: string): Schema {
@@ -141,3 +141,121 @@ test('fragments optimization of selection sets', () => {
     }
   `);
 });
+
+describe('selection set freezing', () => {
+  const schema = parseSchema(`
+    type Query {
+      t: T
+    }
+
+    type T {
+      a: Int
+      b: Int
+    }
+  `);
+
+  const tField = schema.schemaDefinition.rootType('query')!.field('t')!;
+
+  it('throws if one tries to modify a frozen selection set', () => {
+    // Note that we use parseOperation to help us build selection/selection sets because it's more readable/convenient
+    // thant to build the object "programmatically".
+    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet;
+    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet;
+
+    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
+
+    // Control: check we can add to the selection set while not yet frozen
+    expect(s.isFrozen()).toBeFalsy();
+    expect(() => s.mergeIn(s1)).not.toThrow();
+
+    s.freeze();
+    expect(s.isFrozen()).toBeTruthy();
+    expect(() => s.mergeIn(s2)).toThrowError('Cannot add to frozen selection: { t { a } }');
+  });
+
+  it('it does not clone non-frozen selections when adding to another one', () => {
+    // This test is a bit debatable because what it tests is not so much a behaviour
+    // we *need* absolutely to preserve, but rather test how things happens to
+    // behave currently and illustrate the current contrast between frozen and
+    // non-frozen selection set.
+    // That is, this test show what happens if the test
+    //   "it automaticaly clones frozen selections when adding to another one"
+    // is done without freezing.
+
+    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet;
+    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet;
+    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
+
+    s.mergeIn(s1);
+    s.mergeIn(s2);
+
+    expect(s.toString()).toBe('{ t { a b } }');
+
+    // This next assertion is where differs from the case where `s1` is frozen. Namely,
+    // when we do `s.mergeIn(s1)`, then `s` directly references `s1` without cloning
+    // and thus the next modification (`s.mergeIn(s2)`) ends up modifying both `s` and `s1`.
+    // Note that we don't mean by this test that the fact that `s.mergeIn(s1)` does
+    // not clone `s1` is a behaviour one should *rely* on, but it currently done for
+    // efficiencies sake: query planning does a lot of selection set building through
+    // `SelectionSet::mergeIn` and `SelectionSet::add` and we often pass to those method
+    // newly constructed selections as input, so cloning them would wast CPU and early
+    // query planning benchmarking showed that this could add up on the more expansive
+    // plan computations. This is why freezing exists: it allows us to save cloning
+    // in general, but to protect those selection set we know should be immutable
+    // so they do get cloned in such situation.
+    expect(s1.toString()).toBe('{ t { a b } }');
+    expect(s2.toString()).toBe('{ t { b } }');
+  });
+
+  it('it automaticaly clones frozen field selections when merging to another one', () => {
+    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet.freeze();
+    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet.freeze();
+    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
+
+    s.mergeIn(s1);
+    s.mergeIn(s2);
+
+    // We check S is what we expect...
+    expect(s.toString()).toBe('{ t { a b } }');
+
+    // ... but more importantly for this test, that s1/s2 were not modified.
+    expect(s1.toString()).toBe('{ t { a } }');
+    expect(s2.toString()).toBe('{ t { b } }');
+  });
+
+  it('it automaticaly clones frozen fragment selections when merging to another one', () => {
+    // Note: needlessly complex queries, but we're just ensuring the cloning story works when fragments are involved
+    const s1 = parseOperation(schema, `{ ... on Query { t { ... on T { a } } } }`).selectionSet.freeze();
+    const s2 = parseOperation(schema, `{ ... on Query { t { ... on T { b } } } }`).selectionSet.freeze();
+    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
+
+    s.mergeIn(s1);
+    s.mergeIn(s2);
+
+    expect(s.toString()).toBe('{ ... on Query { t { ... on T { a b } } } }');
+
+    expect(s1.toString()).toBe('{ ... on Query { t { ... on T { a } } } }');
+    expect(s2.toString()).toBe('{ ... on Query { t { ... on T { b } } } }');
+  });
+
+  it('it automaticaly clones frozen field selections when adding to another one', () => {
+    const s1 = parseOperation(schema, `{ t { a } }`).selectionSet.freeze();
+    const s2 = parseOperation(schema, `{ t { b } }`).selectionSet.freeze();
+    const s = new SelectionSet(schema.schemaDefinition.rootType('query')!);
+    const tSelection = new FieldSelection(new Field(tField));
+    s.add(tSelection);
+
+    // Note that this test both checks the auto-cloning for the `add` method, but
+    // also shows that freezing dose apply deeply (since we freeze the whole `s1`/`s2`
+    // but only add some sub-selection of it).
+    tSelection.selectionSet!.add(s1.selections()[0].selectionSet!.selections()[0]);
+    tSelection.selectionSet!.add(s2.selections()[0].selectionSet!.selections()[0]);
+
+    // We check S is what we expect...
+    expect(s.toString()).toBe('{ t { a b } }');
+
+    // ... but more importantly for this test, that s1/s2 were not modified.
+    expect(s1.toString()).toBe('{ t { a } }');
+    expect(s2.toString()).toBe('{ t { b } }');
+  });
+});

package/src/__tests__/removeInaccessibleElements.test.ts

@@ -2423,4 +2423,51 @@ describe("removeInaccessibleElements", () => {
       ]
     `);
   });
+
+  it(`fails to remove @inaccessible non-core feature elements referenced by core feature elements`, () => {
+    const schema = buildSchema(`
+      directive @core(feature: String!, as: String, for: core__Purpose) repeatable on SCHEMA
+
+      enum core__Purpose {
+        EXECUTION
+        SECURITY
+      }
+
+      directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+      schema
+        @core(feature: "https://specs.apollo.dev/core/v0.2")
+        @core(feature: "https://specs.apollo.dev/inaccessible/v0.2")
+        @core(feature: "http://localhost/foo/v1.0")
+      {
+        query: Query
+      }
+
+      type Query {
+        someField: String
+      }
+
+      # Inaccessible input object field
+      input InputObject {
+        someField: String
+        privateField: String @inaccessible
+      }
+
+      # Inaccessible input object field can't be referenced by default value of
+      # directive argument of a core feature element
+      directive @foo__referencer(
+        someArg: InputObject = { privateField: "" }
+      ) on FIELD
+    `);
+
+    const errorMessages = expectErrors(1, () => {
+      removeInaccessibleElements(schema);
+    });
+
+    expect(errorMessages).toMatchInlineSnapshot(`
+      Array [
+        "Input field \\"InputObject.privateField\\" is @inaccessible but is used in the default value of \\"@foo__referencer(someArg:)\\", which is in the API schema.",
+      ]
+    `);
+  });
 });

package/src/buildSchema.ts

@@ -79,8 +79,13 @@ export function buildSchemaFromAST(
   // to the schema element. But that detection necessitates that the corresponding directive definition has been fully
   // 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).
+  // Note that one subtlety is that we skip, for now, directive _applications_ within those directive definitions (we can
+  // have such applications on the arguments). The reason is again core schema related: we haven't yet properly detected
+  // if the schema if a core-schema yet, and for federation subgraphs, we haven't yet "imported" federation definitions.
+  // So if one of those directive application was relying on that "importing", it would fail at this point. Which is why
+  // directive application is delayed to later in that method.
   for (const directiveDefinitionNode of directiveDefinitions) {
-    buildDirectiveDefinitionInner(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!, errors);
+    buildDirectiveDefinitionInnerWithoutDirectiveApplications(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!, errors);
   }
   for (const schemaDefinition of schemaDefinitions) {
     buildSchemaDefinitionInner(schemaDefinition, schema.schemaDefinition, errors);
@@ -89,8 +94,17 @@ export function buildSchemaFromAST(
     buildSchemaDefinitionInner(schemaExtension, schema.schemaDefinition, errors, schema.schemaDefinition.newExtension());
   }
 
+  // The following is a no-op for "standard" schema, but for federation subgraphs, this is where we handle the auto-addition
+  // of imported federation directive definitions. That is why we have avoid looking at directive applications within
+  // directive definition earlier: if one of those application was of an imported federation directive, the definition
+  // wouldn't be presence before this point and we'd have triggered an error. After this, we can handle any directive
+  // application safely.
   errors.push(...schema.blueprint.onDirectiveDefinitionAndSchemaParsed(schema));
 
+  for (const directiveDefinitionNode of directiveDefinitions) {
+    buildDirectiveApplicationsInDirectiveDefinition(directiveDefinitionNode, schema.directive(directiveDefinitionNode.name.value)!, errors);
+  }
+
   for (const definitionNode of documentNode.definitions) {
     switch (definitionNode.kind) {
       case 'OperationDefinition':
@@ -360,7 +374,7 @@ function buildFieldDefinitionInner(
   const type = buildTypeReferenceFromAST(fieldNode.type, field.schema());
   field.type = validateOutputType(type, field.coordinate, fieldNode, errors);
   for (const inputValueDef of fieldNode.arguments ?? []) {
-    buildArgumentDefinitionInner(inputValueDef, field.addArgument(inputValueDef.name.value), errors);
+    buildArgumentDefinitionInner(inputValueDef, field.addArgument(inputValueDef.name.value), errors, true);
   }
   buildAppliedDirectives(fieldNode, field, errors);
   field.description = fieldNode.description?.value;
@@ -408,11 +422,14 @@ function buildArgumentDefinitionInner(
   inputNode: InputValueDefinitionNode,
   arg: ArgumentDefinition<any>,
   errors: GraphQLError[],
+  includeDirectiveApplication: boolean,
 ) {
   const type = buildTypeReferenceFromAST(inputNode.type, arg.schema());
   arg.type = validateInputType(type, arg.coordinate, inputNode, errors);
   arg.defaultValue = buildValue(inputNode.defaultValue);
-  buildAppliedDirectives(inputNode, arg, errors);
+  if (includeDirectiveApplication) {
+    buildAppliedDirectives(inputNode, arg, errors);
+  }
   arg.description = inputNode.description?.value;
   arg.sourceAST = inputNode;
 }
@@ -430,13 +447,13 @@ function buildInputFieldDefinitionInner(
   field.sourceAST = fieldNode;
 }
 
-function buildDirectiveDefinitionInner(
+function buildDirectiveDefinitionInnerWithoutDirectiveApplications(
   directiveNode: DirectiveDefinitionNode,
   directive: DirectiveDefinition,
   errors: GraphQLError[],
 ) {
   for (const inputValueDef of directiveNode.arguments ?? []) {
-    buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value), errors);
+    buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value), errors, false);
   }
   directive.repeatable = directiveNode.repeatable;
   const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocation);
@@ -444,3 +461,13 @@ function buildDirectiveDefinitionInner(
   directive.description = directiveNode.description?.value;
   directive.sourceAST = directiveNode;
 }
+
+function buildDirectiveApplicationsInDirectiveDefinition(
+  directiveNode: DirectiveDefinitionNode,
+  directive: DirectiveDefinition,
+  errors: GraphQLError[],
+) {
+  for (const inputValueDef of directiveNode.arguments ?? []) {
+    buildAppliedDirectives(inputValueDef, directive.argument(inputValueDef.name.value)!, errors);
+  }
+}

package/src/definitions.ts

@@ -3215,9 +3215,16 @@ function copy(source: Schema, dest: Schema) {
   for (const type of typesToCopy(source, dest)) {
     dest.addType(newNamedType(type.kind, type.name));
   }
+  // Directives can use other directives in their arguments. So, like types, we first shallow copy
+  // directives so future references to any of them can be dereferenced. We'll copy the actual
+  // definition later after all directives are defined.
   for (const directive of directivesToCopy(source, dest)) {
-    copyDirectiveDefinitionInner(directive, dest.addDirectiveDefinition(directive.name));
+    dest.addDirectiveDefinition(directive.name);
   }
+  for (const directive of directivesToCopy(source, dest)) {
+    copyDirectiveDefinitionInner(directive, dest.directive(directive.name)!);
+  }
+
   copySchemaDefinitionInner(source.schemaDefinition, dest.schemaDefinition);
   for (const type of typesToCopy(source, dest)) {
     copyNamedTypeInner(type, dest.type(type.name)!);