feat: support composing executable directive definitions (#156)

> An executable directive is composed into the supergraph schema only if
all of the following conditions are met:
>
> - The directive is defined in all subgraphs.
> - The directive is defined identically in all subgraphs.
> - The directive is not included in any
[@composeDirective](https://www.apollographql.com/docs/graphos/reference/federation/directives#composedirective)
directives.
>
>
*[Source](https://www.apollographql.com/docs/graphos/schema-design/federated-schemas/reference/composition-rules#executable-directives)*

The last statement is not true, `@composeDirective` does not prevent a
executable directive from being included within the supergraph.

Author: n1ru4l

.changeset/happy-suits-flash.md

@@ -0,0 +1,5 @@
+---
+"@theguild/federation-composition": minor
+---
+
+Support composing executable directive definitions within subgraphs into the supergraph.

__tests__/supergraph/base.spec.ts

@@ -160,4 +160,295 @@ testVersions((api, version) => {
       ]);
     }, "detected exact same urls").not.toThrow();
   });
+
+  test("executable directive definition is retained in supergraph", () => {
+    const result = api.composeServices([
+      {
+        name: "foo",
+        url: "http://foo.com",
+        typeDefs: graphql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+        directive @a(n: Int) on FIELD
+
+        type Query {
+          a: Int
+        }
+      `,
+      },
+    ]);
+    expect(result.supergraphSdl).toContain("directive @a(n: Int)");
+  });
+
+  test("executable directive definition is retained if defined identical in all subgraphs", () => {
+    const result = api.composeServices([
+      {
+        name: "a",
+        url: "http://a.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD
+
+          type Query {
+            a: Int
+          }
+      `,
+      },
+      {
+        name: "b",
+        url: "http://b.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD
+
+          type Query {
+            b: Int
+          }
+        `,
+      },
+    ]);
+    expect(result.supergraphSdl).toContain("directive @a(n: Int)");
+  });
+
+  test("executable directive definition is omitted if only defined within a single subgraph", () => {
+    const result = api.composeServices([
+      {
+        name: "a",
+        url: "http://a.com",
+        typeDefs: graphql`
+        extend schema
+          @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD
+
+          type Query {
+            a: Int
+          }
+        `,
+      },
+      {
+        name: "b",
+        url: "http://b.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          type Query {
+            b: Int
+          }
+        `,
+      },
+    ]);
+    expect(result.supergraphSdl).not.toContain("directive @a(n: Int)");
+  });
+
+  test("executable directive only contains locations shared between all subgraphs", () => {
+    const result = api.composeServices([
+      {
+        name: "a",
+        url: "http://a.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD
+
+          type Query {
+            a: Int
+          }
+        `,
+      },
+      {
+        name: "b",
+        url: "http://b.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD | FRAGMENT_SPREAD
+
+          type Query {
+            b: Int
+          }
+          `,
+      },
+    ]);
+    expect(result.supergraphSdl).toBeDefined();
+    expect(result.supergraphSdl).toContainGraphQL(graphql`
+      directive @a(n: Int) on FIELD
+    `);
+    expect(result.supergraphSdl).not.toContainGraphQL(graphql`
+      directive @a(n: Int) on FIELD | FRAGMENT_SPREAD
+    `);
+  });
+
+  test("executable directive is removed if no locations are shared between all subgraphs", () => {
+    const result = api.composeServices([
+      {
+        name: "a",
+        url: "http://a.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD
+
+          type Query {
+            a: Int
+          }
+        `,
+      },
+      {
+        name: "b",
+        url: "http://b.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FRAGMENT_SPREAD
+
+          type Query {
+            b: Int
+          }
+          `,
+      },
+    ]);
+
+    expect(result.supergraphSdl).toBeDefined();
+    expect(result.supergraphSdl).not.toContain("directive @a(n: Int)");
+  });
+
+  test("executable directive is only included with executable definition locations", () => {
+    const result = api.composeServices([
+      {
+        name: "a",
+        url: "http://a.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            a: Int
+          }
+        `,
+      },
+      {
+        name: "b",
+        url: "http://b.com",
+        typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@key"])
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            b: Int
+          }
+          `,
+      },
+    ]);
+
+    expect(result.supergraphSdl).toBeDefined();
+    expect(result.supergraphSdl).toContainGraphQL(graphql`
+      directive @a(n: Int) on FIELD
+    `);
+  });
+
+  if (version !== "v2.0") {
+    test("executable directive that is also a compose directive is included with executable definition and schema definition locations", () => {
+      const result = api.composeServices([
+        {
+          name: "a",
+          url: "http://a.com",
+          typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@composeDirective"])
+            @link(url: "https://a.dev/a/v1.0", import: ["@a"])
+            @composeDirective(name: "@a")
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            a: Int
+          }
+        `,
+        },
+        {
+          name: "b",
+          url: "http://b.com",
+          typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: [ "@composeDirective"])
+            @link(url: "https://a.dev/a/v1.0", import: ["@a"])
+            @composeDirective(name: "@a")
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            b: Int
+          }
+          `,
+        },
+      ]);
+
+      expect(result.supergraphSdl).toBeDefined();
+      expect(result.supergraphSdl).toContainGraphQL(graphql`
+        directive @a(n: Int) on FIELD | FIELD_DEFINITION
+      `);
+    });
+
+    test("executable directive that is also a compose directive and used within the subgraph schemas is only included with executable definition locations and schema definition locations", () => {
+      const result = api.composeServices([
+        {
+          name: "a",
+          url: "http://a.com",
+          typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@composeDirective"])
+            @link(url: "https://a.dev/a/v1.0", import: ["@a"])
+            @composeDirective(name: "@a")
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            a: Int @a
+          }
+        `,
+        },
+        {
+          name: "b",
+          url: "http://b.com",
+          typeDefs: graphql`
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/${version}", import: [ "@composeDirective"])
+            @link(url: "https://a.dev/a/v1.0", import: ["@a"])
+            @composeDirective(name: "@a")
+
+          directive @a(n: Int) on FIELD | FIELD_DEFINITION
+
+          type Query {
+            b: Int @a
+          }
+          `,
+        },
+      ]);
+      expect(result.supergraphSdl).toBeDefined();
+      expect(result.supergraphSdl).toContainGraphQL(graphql`
+        directive @a(n: Int) on FIELD | FIELD_DEFINITION
+      `);
+      expect(result.supergraphSdl).toContainGraphQL(graphql`
+        type Query @join__type(graph: A) @join__type(graph: B) {
+          a: Int @a @join__field(graph: A)
+          b: Int @a @join__field(graph: B)
+        }
+      `);
+    });
+  }
 });