fix: invalid public sdl for inaccessible interface type (#198)

The public schema SDL is wrong when it implements an inaccessible
interface type, it retains the interface implementation even though it
is not part of the public schema.

See changeset for an example diff of what was fixed

Author: n1ru4l

.changeset/huge-toes-mix.md

@@ -0,0 +1,43 @@
+---
+"@theguild/federation-composition": patch
+---
+
+Fix public schema SDL in case a object type implements an inaccessible interface.
+
+
+Composing the following subgraph:
+
+```graphql
+schema
+  @link(
+    url: "https://specs.apollo.dev/federation/v2.3"
+    import: ["@inaccessible"]
+  ) {
+  query: Query
+}
+
+type Query {
+  user: User!
+}
+
+interface Node @inaccessible {
+  id: ID!
+}
+
+type User implements Node {
+  id: ID!
+}
+```
+
+now result in the following valid public SDL:
+
+```diff
+  type Query {
+    user: User!
+  }
+
+- type User implements Node {
++ type User {
+    id: ID!
+  }
+```

__tests__/composition.spec.ts

@@ -7925,4 +7925,132 @@ testImplementations((api) => {
       `Invalid value for "@tag(name:)" of type "String!" in application of "@tag" to "Query.foo".`,
     );
   });
+
+  test("inaccessible interface implemented by accessible types", () => {
+    const sdl = /* GraphQL */ `
+      schema
+        @link(
+          url: "https://specs.apollo.dev/federation/v2.3"
+          import: ["@inaccessible"]
+        ) {
+        query: Query
+      }
+
+      type Query {
+        public: PublicAccessTokenConnection!
+        private: PrivateAccessTokenConnection! @inaccessible
+      }
+
+      interface AccessToken @inaccessible {
+        id: ID!
+      }
+
+      interface AccessTokenEdge @inaccessible {
+        node: AccessToken!
+      }
+
+      interface AccessTokenConnection @inaccessible {
+        edges: [AccessTokenEdge!]!
+      }
+
+      type PrivateAccessToken implements AccessToken @inaccessible {
+        id: ID!
+      }
+
+      type PrivateAccessTokenEdge implements AccessTokenEdge @inaccessible {
+        node: PrivateAccessToken!
+      }
+
+      type PrivateAccessTokenConnection implements AccessTokenConnection
+        @inaccessible {
+        edges: [PrivateAccessTokenEdge!]!
+      }
+
+      type PublicAccessToken implements AccessToken {
+        id: ID!
+      }
+
+      type PublicAccessTokenEdge implements AccessTokenEdge {
+        node: PublicAccessToken!
+      }
+
+      type PublicAccessTokenConnection implements AccessTokenConnection {
+        edges: [PublicAccessTokenEdge!]!
+      }
+    `;
+
+    const result = api.composeServices([
+      {
+        typeDefs: parse(sdl),
+        name: "FOO_GRAPHQL",
+        url: "https://lol.de",
+      },
+    ]);
+
+    expect(result.errors).toEqual(undefined);
+    expect(result.supergraphSdl).toContainGraphQL(/* GraphQL */ `
+      type PrivateAccessToken implements AccessToken
+        @join__implements(graph: FOO_GRAPHQL, interface: "AccessToken")
+        @join__type(graph: FOO_GRAPHQL)
+        @inaccessible {
+        id: ID!
+      }
+
+      type PrivateAccessTokenConnection implements AccessTokenConnection
+        @join__implements(
+          graph: FOO_GRAPHQL
+          interface: "AccessTokenConnection"
+        )
+        @join__type(graph: FOO_GRAPHQL)
+        @inaccessible {
+        edges: [PrivateAccessTokenEdge!]!
+      }
+
+      type PrivateAccessTokenEdge implements AccessTokenEdge
+        @join__implements(graph: FOO_GRAPHQL, interface: "AccessTokenEdge")
+        @join__type(graph: FOO_GRAPHQL)
+        @inaccessible {
+        node: PrivateAccessToken!
+      }
+
+      type PublicAccessToken implements AccessToken
+        @join__implements(graph: FOO_GRAPHQL, interface: "AccessToken")
+        @join__type(graph: FOO_GRAPHQL) {
+        id: ID!
+      }
+
+      type PublicAccessTokenConnection implements AccessTokenConnection
+        @join__implements(
+          graph: FOO_GRAPHQL
+          interface: "AccessTokenConnection"
+        )
+        @join__type(graph: FOO_GRAPHQL) {
+        edges: [PublicAccessTokenEdge!]!
+      }
+
+      type PublicAccessTokenEdge implements AccessTokenEdge
+        @join__implements(graph: FOO_GRAPHQL, interface: "AccessTokenEdge")
+        @join__type(graph: FOO_GRAPHQL) {
+        node: PublicAccessToken!
+      }
+    `);
+    assertCompositionSuccess(result);
+    expect(result.publicSdl).toContainGraphQL(`
+      type Query {
+        public: PublicAccessTokenConnection!
+      }
+
+      type PublicAccessToken {
+        id: ID!
+      }
+
+      type PublicAccessTokenEdge {
+        node: PublicAccessToken!
+      }
+
+      type PublicAccessTokenConnection {
+        edges: [PublicAccessTokenEdge!]!
+      }
+    `);
+  });
 });

src/graphql/transform-supergraph-to-public-schema.ts

@@ -1,5 +1,6 @@
 import {
   Kind,
+  type NamedTypeNode,
   specifiedDirectives as specifiedDirectivesArray,
   visit,
   type ConstDirectiveNode,
@@ -157,18 +158,24 @@ export function transformSupergraphToPublicSchema(
     );
   }
 
+  const inaccessibleInterfaceTypes = new Set<string>();
+
   function removeInaccessibleNode(node: {
+    kind: Kind;
     directives?: readonly ConstDirectiveNode[];
     name: {
       value: string;
     };
   }) {
     if (hasInaccessibleDirective(node) || belongsToLinkedSpec(node)) {
+      if (node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+        inaccessibleInterfaceTypes.add(node.name.value);
+      }
       return null;
     }
   }
 
-  return visit(documentNode, {
+  const newDocumentNode = visit(documentNode, {
     [Kind.DIRECTIVE_DEFINITION]: removeFederationOrSpecifiedDirectives,
     [Kind.DIRECTIVE]: removeFederationOrSpecifiedDirectives,
     [Kind.SCHEMA_EXTENSION]: () => null,
@@ -212,4 +219,40 @@ export function transformSupergraphToPublicSchema(
     },
     [Kind.INPUT_VALUE_DEFINITION]: removeInaccessibleNode,
   });
+
+  if (!inaccessibleInterfaceTypes.size) {
+    return newDocumentNode;
+  }
+
+  // If there are inaccessible interface types we need to visit the document a second time and filter these out.
+
+  function removeInaccessibleInterfaces(node: {
+    directives?: readonly ConstDirectiveNode[];
+    name: {
+      value: string;
+    };
+    interfaces?: readonly NamedTypeNode[] | undefined;
+  }) {
+    if (!node.interfaces) {
+      return;
+    }
+
+    const newInterfaces = node.interfaces.filter(
+      (value) => !inaccessibleInterfaceTypes.has(value.name.value),
+    );
+
+    if (newInterfaces.length === node.interfaces.length) {
+      return;
+    }
+
+    return {
+      ...node,
+      interfaces: newInterfaces,
+    };
+  }
+
+  return visit(newDocumentNode, {
+    [Kind.OBJECT_TYPE_DEFINITION]: removeInaccessibleInterfaces,
+    [Kind.INTERFACE_TYPE_DEFINITION]: removeInaccessibleInterfaces,
+  });
 }