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

package/src/__tests__/definitions.test.ts

@@ -590,6 +590,72 @@ test('default arguments for directives', () => {
   expect(d3.arguments(true)).toEqual({ inputObject: { number: 3 }});
 });
 
+describe('clone', () => {
+  it('should allow directive application before definition', () => {
+    const schema = buildSchema(`
+      directive @foo(arg: String @wizz(arg: "foo")) on FIELD_DEFINITION
+      directive @wizz(arg: String @fuzz(arg: "wizz")) on ARGUMENT_DEFINITION
+      directive @fuzz(arg: String @buzz(arg: "fuzz")) on ARGUMENT_DEFINITION
+      directive @buzz(arg: String @baz(arg: "buzz")) on ARGUMENT_DEFINITION
+      directive @baz(arg: String @bar) on ARGUMENT_DEFINITION
+      directive @bar on ARGUMENT_DEFINITION
+
+      type Query {
+        foo: String! @foo(arg: "query")
+      }
+    `).clone();
+
+    expect(schema.elementByCoordinate("@foo")).toBeDefined();
+    expect(schema.elementByCoordinate("@wizz")).toBeDefined();
+    expect(schema.elementByCoordinate("@fuzz")).toBeDefined();
+    expect(schema.elementByCoordinate("@buzz")).toBeDefined();
+    expect(schema.elementByCoordinate("@baz")).toBeDefined();
+    expect(schema.elementByCoordinate("@bar")).toBeDefined();
+  });
+
+  // https://github.com/apollographql/federation/issues/1794
+  it('should allow using an imported federation diretive in another directive', () => {
+    const schema = buildSubgraph('foo', "", `
+      extend schema
+        @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@tag"])
+
+      directive @foo(arg: String @tag(name: "tag")) on FIELD_DEFINITION
+
+      type Query {
+        hi: String! @foo
+      }
+    `).schema.clone();
+    expect(schema.elementByCoordinate("@foo")).toBeDefined();
+    expect(schema.elementByCoordinate("@tag")).toBeDefined();
+  });
+
+  it('should allow type use in directives', () => {
+    const schema = buildSchema(`
+      directive @foo(arg: Thing!) on FIELD_DEFINITION
+      scalar Thing
+
+      type Query {
+        foo: String! @foo(arg: "sunshine")
+      }
+    `).clone();
+
+    expect(schema.elementByCoordinate("@foo")).toBeDefined();
+  });
+
+  it('should allow recursive directive definitions', () => {
+    const schema = buildSchema(`
+      directive @foo(a: Int @bar) on ARGUMENT_DEFINITION
+      directive @bar(b: Int @foo) on ARGUMENT_DEFINITION
+
+      type Query {
+        getData(arg: String @foo): String!
+      }
+    `).clone();
+    expect(schema.elementByCoordinate("@foo")).toBeDefined();
+    expect(schema.elementByCoordinate("@bar")).toBeDefined();
+  });
+});
+
 test('correctly convert to a graphQL-js schema', () => {
   const sdl = `
     schema {

package/src/__tests__/extractSubgraphsFromSupergraph.test.ts

@@ -597,3 +597,86 @@ test('throw meaningful error for invalid federation directive fieldSet', () => {
     + '[serviceB] On field "A.a", for @requires(fields: "b { x }"): Cannot query field "b" on type "A" (if the field is defined in another subgraph, you need to add it to this subgraph with @external).'
   );
 })
+
+
+test('throw meaningful error for type erased from supergraph due to extending an entity without a key', () => {
+  // Supergraph generated by fed1 composition from:
+  // ServiceA:
+  //     type Query {
+  //       t: T
+  //     }
+  //
+  //     type T @key(fields: "id") {
+  //       id: ID!
+  //       x: Int!
+  //     }
+  //
+  // ServiceB
+  //     extend type T {
+  //       x: Int! @external
+  //     }
+  //
+  //     type Other {
+  //       f: T @provides(fields: "x")
+  //     }
+  //
+  // The issue of that schema is that `T` is referenced in `ServiceB`, but because it extends an entity type
+  // without a key and has noly external field, ther is no remaining traces of it's definition in `ServiceB`
+  // in the supergraph. As extract cannot make up the original definition out of thin air, it ends up erroring
+  // when extracting `Other.t` due to not knowing that type.
+  const supergraph = `
+    schema
+      @core(feature: "https://specs.apollo.dev/core/v0.2"),
+      @core(feature: "https://specs.apollo.dev/join/v0.1", for: EXECUTION)
+    {
+      query: Query
+    }
+
+    directive @core(as: String, feature: String!, for: core__Purpose) repeatable on SCHEMA
+
+    directive @join__field(graph: join__Graph, provides: join__FieldSet, requires: join__FieldSet) on FIELD_DEFINITION
+
+    directive @join__graph(name: String!, url: String!) on ENUM_VALUE
+
+    directive @join__owner(graph: join__Graph!) on INTERFACE | OBJECT
+
+    directive @join__type(graph: join__Graph!, key: join__FieldSet) repeatable on INTERFACE | OBJECT
+
+    type Other {
+      f: T @join__field(graph: SERVICEB, provides: "x")
+    }
+
+    type Query {
+      t: T @join__field(graph: SERVICEA)
+    }
+
+    type T
+      @join__owner(graph: SERVICEA)
+      @join__type(graph: SERVICEA, key: "id")
+    {
+      id: ID! @join__field(graph: SERVICEA)
+      x: Int! @join__field(graph: SERVICEA)
+    }
+
+    enum core__Purpose {
+      EXECUTION
+      SECURITY
+    }
+
+    scalar join__FieldSet
+
+    enum join__Graph {
+      SERVICEA @join__graph(name: "serviceA" url: "")
+      SERVICEB @join__graph(name: "serviceB" url: "")
+    }
+  `;
+
+  const schema = buildSupergraphSchema(supergraph)[0];
+  expect(() => extractSubgraphsFromSupergraph(schema)).toThrow(
+    'Error extracting subgraphs from the supergraph: this might be due to errors in subgraphs that were mistakenly ignored by federation 0.x versions but are rejected by federation 2.\n'
+    + 'Please try composing your subgraphs with federation 2: this should help precisely pinpoint the problems and, once fixed, generate a correct federation 2 supergraph.\n'
+    + '\n'
+    + 'Details:\n'
+    + 'Error: Cannot find type "T" in subgraph "serviceB"'
+  );
+})

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

@@ -178,7 +178,7 @@ describe("removeInaccessibleElements", () => {
     `);
   });
 
-  it(`handles renames of @inaccessible`, () => {
+  it(`handles renames of @inaccessible via core "as"`, () => {
     const schema = buildSchema(`
       directive @core(feature: String!, as: String, for: core__Purpose) repeatable on SCHEMA
 
@@ -212,6 +212,42 @@ describe("removeInaccessibleElements", () => {
     expect(schema.elementByCoordinate("Query.privateField")).toBeUndefined();
   });
 
+  it(`handles renames of @inaccessible via import "as"`, () => {
+    const schema = buildSchema(`
+      directive @link(url: String, as: String, for: link__Purpose, import: [link__Import]) repeatable on SCHEMA
+
+      enum link__Purpose {
+        EXECUTION
+        SECURITY
+      }
+
+      scalar link__Import
+
+      directive @foo on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+      schema
+        @link(url: "https://specs.apollo.dev/link/v1.0")
+        @link(url: "https://specs.apollo.dev/inaccessible/v0.2", import: [{name: "@inaccessible", as: "@foo"}])
+      {
+        query: Query
+      }
+
+      type Query {
+        someField: Bar @inaccessible
+        privateField: String @foo
+      }
+
+      scalar Bar
+
+      directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+    `);
+
+    removeInaccessibleElements(schema);
+    schema.validate();
+    expect(schema.elementByCoordinate("Query.someField")).toBeDefined();
+    expect(schema.elementByCoordinate("Query.privateField")).toBeUndefined();
+  });
+
   it(`fails for @inaccessible built-ins`, () => {
     const schema = buildSchema(`
       ${INACCESSIBLE_V02_HEADER}
@@ -2387,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/__tests__/schemaUpgrader.test.ts

@@ -1,4 +1,5 @@
 import { FEDERATION2_LINK_WTH_FULL_IMPORTS } from '..';
+import { ObjectType } from '../definitions';
 import { buildSubgraph, Subgraphs } from '../federation';
 import { UpgradeChangeID, UpgradeResult, upgradeSubgraphsIfNecessary } from '../schemaUpgrader';
 import './matchers';
@@ -167,3 +168,40 @@ test('update federation directive non-string arguments', () => {
     }
   `);
 })
+
+
+test('remove tag on external field if found on definition', () => {
+  const s1 = `
+    type Query {
+      a: A @provides(fields: "y")
+    }
+
+    type A @key(fields: "id") {
+      id: String
+      x: Int
+      y: Int @external @tag(name: "a tag")
+    }
+  `;
+
+  const s2 = `
+    type A @key(fields: "id") {
+      id: String
+      y: Int @tag(name: "a tag")
+    }
+  `;
+
+  const subgraphs = new Subgraphs();
+  subgraphs.add(buildSubgraph('s1', 'http://s1', s1));
+  subgraphs.add(buildSubgraph('s2', 'http://s2', s2));
+  const res = upgradeSubgraphsIfNecessary(subgraphs);
+  expect(res.errors).toBeUndefined();
+
+  expect(changeMessages(res, 's1', 'REMOVED_TAG_ON_EXTERNAL')).toStrictEqual([
+    'Removed @tag(name: "a tag") application on @external "A.y" as the @tag application is on another definition',
+  ]);
+
+  const typeAInS1 = res.subgraphs?.get('s1')?.schema.type("A") as ObjectType;
+  const typeAInS2 = res.subgraphs?.get('s2')?.schema.type("A") as ObjectType;
+  expect(typeAInS1.field("y")?.appliedDirectivesOf('tag').map((d) => d.toString())).toStrictEqual([]);
+  expect(typeAInS2.field("y")?.appliedDirectivesOf('tag').map((d) => d.toString())).toStrictEqual([ '@tag(name: "a tag")' ]);
+})

package/src/__tests__/subgraphValidation.test.ts

@@ -879,3 +879,77 @@ describe('@core/@link handling', () => {
     buildAndValidate(doc);
   });
 });
+
+describe('federation 1 schema', () => {
+  it('accepts federation directive definitions without arguments', () => {
+    const doc = gql`
+      type Query {
+        a: Int
+      }
+
+      directive @key on OBJECT | INTERFACE
+      directive @requires on FIELD_DEFINITION
+    `;
+
+    buildAndValidate(doc);
+  });
+
+  it('accepts federation directive definitions with nullable arguments', () => {
+    const doc = gql`
+      type Query {
+        a: Int
+      }
+
+      type T @key(fields: "id") {
+        id: ID! @requires(fields: "x")
+        x: Int @external
+      }
+
+      # Tests with the _FieldSet argument non-nullable
+      scalar _FieldSet
+      directive @key(fields: _FieldSet) on OBJECT | INTERFACE
+
+      # Tests with the argument as String and non-nullable
+      directive @requires(fields: String) on FIELD_DEFINITION
+    `;
+
+    buildAndValidate(doc);
+  });
+
+  it('accepts federation directive definitions with "FieldSet" type instead of "_FieldSet"', () => {
+    const doc = gql`
+      type Query {
+        a: Int
+      }
+
+      type T @key(fields: "id") {
+        id: ID!
+      }
+
+      scalar FieldSet
+      directive @key(fields: FieldSet) on OBJECT | INTERFACE
+    `;
+
+    buildAndValidate(doc);
+  });
+
+  it('rejects federation directive definition with unknown arguments', () => {
+    const doc = gql`
+      type Query {
+        a: Int
+      }
+
+      type T @key(fields: "id", unknown: 42) {
+        id: ID!
+      }
+
+      scalar _FieldSet
+      directive @key(fields: _FieldSet!, unknown: Int) on OBJECT | INTERFACE
+    `;
+
+    expect(buildForErrors(doc, { asFed2: false })).toStrictEqual([[
+      'DIRECTIVE_DEFINITION_INVALID',
+      '[S] Invalid definition for directive "@key": unknown/unsupported argument "unknown"'
+    ]]);
+  });
+})

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/coreSpec.ts

@@ -131,6 +131,10 @@ export abstract class FeatureDefinition {
     return features.getByIdentity(this.identity);
   }
 
+  get defaultCorePurpose(): CorePurpose | undefined {
+    return undefined;
+  }
+
   toString(): string {
     return `${this.identity}/${this.version}`
   }

package/src/definitions.ts

@@ -946,11 +946,13 @@ export class CoreFeature {
   }
 
   directiveNameInSchema(name: string): string {
-    if (name === this.url.name) {
-      return this.nameInSchema;
-    }
     const elementImport = this.imports.find((i) => i.name.charAt(0) === '@' && i.name.slice(1) === name);
-    return elementImport ? (elementImport.as?.slice(1) ?? name) : this.nameInSchema + '__' + name;
+    return elementImport
+      ? (elementImport.as?.slice(1) ?? name)
+      : (name === this.url.name
+        ? this.nameInSchema
+        : this.nameInSchema + '__' + name
+      );
   }
 
   typeNameInSchema(name: string): string {
@@ -2762,7 +2764,7 @@ export class DirectiveDefinition<TApplicationArgs extends {[key: string]: any} =
     assert(false, `Directive definition ${this} can't reference other types (it's arguments can); shouldn't be asked to remove reference to ${type}`);
   }
 
-    /**
+  /**
    * Removes this directive definition from its parent schema.
    *
    * After calling this method, this directive definition will be "detached": it will have no parent, schema, or
@@ -3213,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)!);