fix(composition): Check value of resolvable arg when looking for resolvable keys (#8694)

Author: tninesling

apollo-federation/src/merger/merge_interface.rs

@@ -37,7 +37,13 @@ impl Merger {
             let interface_pos: TypeDefinitionPosition = dest.clone().into();
             let keys = interface_pos.get_applied_directives(subgraph.schema(), &key_directive_name);
             has_key = has_key || !keys.is_empty();
-            let Some(resolvable_key) = keys.iter().find(|key| !key.arguments.is_empty()) else {
+            let federation_spec_definition = subgraph.metadata().federation_spec_definition();
+            let Some(resolvable_key) = keys.iter().find(|key| {
+                federation_spec_definition
+                    .key_directive_arguments(key)
+                    .map(|args| args.resolvable)
+                    .unwrap_or(true) // @key(resolvable:) defaults to true in its definition
+            }) else {
                 continue;
             };
             let implementations_in_subgraph = subgraph

apollo-federation/tests/composition/compose_interface_object.rs

@@ -543,3 +543,54 @@ fn interface_object_with_inaccessible_field() {
         "id field should have @join__field for subgraph-c"
     );
 }
+
+#[test]
+fn interface_with_non_resolvable_key_does_not_require_all_implementations() {
+    // subgraphA defines the interface with a resolvable key and all implementations
+    let subgraph_a = ServiceDefinition {
+        name: "subgraphA",
+        type_defs: r#"
+        type Query {
+          iFromA: I
+        }
+
+        interface I @key(fields: "id") {
+          id: ID!
+          x: Int
+        }
+
+        type A implements I @key(fields: "id") {
+          id: ID!
+          x: Int
+        }
+
+        type B implements I @key(fields: "id") {
+          id: ID!
+          x: Int
+        }
+
+        type C implements I @key(fields: "id") {
+          id: ID!
+          x: Int
+        }
+        "#,
+    };
+
+    // subgraphB defines the interface with a non-resolvable key but does not
+    // define the implementations
+    let subgraph_b = ServiceDefinition {
+        name: "subgraphB",
+        type_defs: r#"
+        interface I @key(fields: "id", resolvable: false) {
+          id: ID!
+          x: Int
+        }
+        "#,
+    };
+
+    let result = compose_as_fed2_subgraphs(&[subgraph_a, subgraph_b]);
+    // This should not error because a non-resolvable key doesn't require all implementations
+    let _supergraph = result.expect(
+        "Expected composition to succeed - non-resolvable interface key should not require all implementations"
+    );
+}