feat: support @OneOf composition with consistency validation

Adds composition support for the @OneOf directive. When merging input
object types, validates that all subgraphs defining the type agree on
whether @OneOf is applied. Reports INPUT_OBJECT_ONE_OF_MISMATCH if
some subgraphs mark the input as @OneOf and others do not.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tninesling

apollo-federation/src/error/mod.rs

@@ -289,6 +289,11 @@ pub enum CompositionError {
         message: String,
         locations: Locations,
     },
+    #[error("{message}")]
+    InputObjectOneOfMismatch {
+        message: String,
+        locations: Locations,
+    },
 }
 
 impl CompositionError {
@@ -357,6 +362,7 @@ impl CompositionError {
             Self::ArgumentDefaultMismatch { .. } => ErrorCode::FieldArgumentDefaultMismatch,
             Self::InputFieldDefaultMismatch { .. } => ErrorCode::InputFieldDefaultMismatch,
             Self::InterfaceFieldNoImplem { .. } => ErrorCode::InterfaceFieldNoImplem,
+            Self::InputObjectOneOfMismatch { .. } => ErrorCode::InputObjectOneOfMismatch,
         }
     }
 
@@ -486,6 +492,12 @@ impl CompositionError {
                 message: format!("{message}{appendix}"),
                 locations,
             },
+            Self::InputObjectOneOfMismatch { message, locations } => {
+                Self::InputObjectOneOfMismatch {
+                    message: format!("{message}{appendix}"),
+                    locations,
+                }
+            }
             // Remaining errors do not have an obvious way to appending a message, so we just return self.
             Self::SubgraphError { .. }
             | Self::MergeError { .. }
@@ -518,7 +530,8 @@ impl CompositionError {
             | Self::InvalidFieldSharing { locations, .. }
             | Self::MergeError { locations, .. }
             | Self::ArgumentDefaultMismatch { locations, .. }
-            | Self::InputFieldDefaultMismatch { locations, .. } => locations.extend(new_locations),
+            | Self::InputFieldDefaultMismatch { locations, .. }
+            | Self::InputObjectOneOfMismatch { locations, .. } => locations.extend(new_locations),
             // Remaining errors do not have an obvious way to appending locations, so we do nothing
             _ => {}
         }
@@ -538,7 +551,8 @@ impl CompositionError {
             | Self::MergeError { locations, .. }
             | Self::ArgumentDefaultMismatch { locations, .. }
             | Self::InputFieldDefaultMismatch { locations, .. }
-            | Self::InterfaceFieldNoImplem { locations, .. } => locations,
+            | Self::InterfaceFieldNoImplem { locations, .. }
+            | Self::InputObjectOneOfMismatch { locations, .. } => locations,
             _ => &[],
         }
     }
@@ -2576,6 +2590,14 @@ static MISSING_TRANSITIVE_AUTH_REQUIREMENTS: LazyLock<ErrorCodeDefinition> = Laz
         )
 });
 
+static INPUT_OBJECT_ONE_OF_MISMATCH: LazyLock<ErrorCodeDefinition> = LazyLock::new(|| {
+    ErrorCodeDefinition::new(
+        "INPUT_OBJECT_ONE_OF_MISMATCH".to_owned(),
+        "An input object type has the @oneOf directive in some subgraphs but not all subgraphs that define the type.".to_owned(),
+        None,
+    )
+});
+
 #[derive(Debug, PartialEq, strum_macros::EnumIter)]
 pub enum ErrorCode {
     ErrorCodeMissing,
@@ -2685,6 +2707,7 @@ pub enum ErrorCode {
     QueryRootMissing,
     AuthRequirementsAppliedOnInterface,
     MissingTransitiveAuthRequirements,
+    InputObjectOneOfMismatch,
 }
 
 impl ErrorCode {
@@ -2821,6 +2844,7 @@ impl ErrorCode {
                 &AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE
             }
             ErrorCode::MissingTransitiveAuthRequirements => &MISSING_TRANSITIVE_AUTH_REQUIREMENTS,
+            ErrorCode::InputObjectOneOfMismatch => &INPUT_OBJECT_ONE_OF_MISMATCH,
         }
     }
 }

apollo-federation/src/merger/merge_input.rs

@@ -26,6 +26,8 @@ impl Merger {
         sources: &Sources<Node<InputObjectType>>,
         dest: &InputObjectTypeDefinitionPosition,
     ) -> Result<(), FederationError> {
+        self.validate_one_of_consistency(sources, dest);
+
         // Like for other inputs, we add all the fields found in any subgraphs initially as a simple mean to have a complete list of
         // field to iterate over, but we will remove those that are not in all subgraphs.
         let added = self.add_input_fields_shallow(sources, dest)?;
@@ -276,4 +278,39 @@ impl Merger {
         self.merge_default_value(sources, dest_field)?;
         Ok(())
     }
+
+    fn validate_one_of_consistency(
+        &mut self,
+        sources: &Sources<Node<InputObjectType>>,
+        dest: &InputObjectTypeDefinitionPosition,
+    ) {
+        let mut with_one_of: Vec<String> = Vec::new();
+        let mut without_one_of: Vec<String> = Vec::new();
+
+        for (idx, source) in sources {
+            let Some(source) = source else {
+                continue;
+            };
+            let has_one_of = source.directives.has("oneOf");
+            let subgraph_name = self.names[*idx].to_string();
+            if has_one_of {
+                with_one_of.push(subgraph_name);
+            } else {
+                without_one_of.push(subgraph_name);
+            }
+        }
+
+        if !with_one_of.is_empty() && !without_one_of.is_empty() {
+            let with_str = human_readable_subgraph_names(with_one_of.iter());
+            let without_str = human_readable_subgraph_names(without_one_of.iter());
+            self.error_reporter
+                .add_error(CompositionError::InputObjectOneOfMismatch {
+                    message: format!(
+                        "Input object type \"{}\" is marked with @oneOf in {} but not in {}",
+                        dest.type_name, with_str, without_str,
+                    ),
+                    locations: self.source_locations(sources),
+                });
+        }
+    }
 }

apollo-federation/src/merger/merger.rs

@@ -120,11 +120,12 @@ static NON_MERGED_CORE_FEATURES: LazyLock<[Identity; 4]> = LazyLock::new(|| {
 
 /// In JS, this is encoded indirectly in `isGraphQLBuiltInDirective`. Regardless of whether
 /// the end user redefined these directives, we consider them built-in for merging.
-static BUILT_IN_DIRECTIVES: [&str; 6] = [
+static BUILT_IN_DIRECTIVES: [&str; 7] = [
     "skip",
     "include",
     "deprecated",
     "specifiedBy",
+    "oneOf",
     "defer",
     "stream",
 ];

apollo-federation/tests/composition/compose_types.rs

@@ -506,3 +506,170 @@ fn union_types_merges_inconsistent_unions() {
         .expect("Union U should exist");
     assert_snapshot!(union_u, @"union U = A | B | C");
 }
+
+// =============================================================================
+// @oneOf INPUT OBJECTS - Tests for @oneOf directive merging behavior
+// =============================================================================
+
+#[test]
+fn one_of_input_object_merges_when_consistent() {
+    let subgraph_a = ServiceDefinition {
+        name: "subgraphA",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let subgraph_b = ServiceDefinition {
+        name: "subgraphB",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let result = compose_as_fed2_subgraphs(&[subgraph_a, subgraph_b]);
+    let supergraph = result.expect("Expected composition to succeed");
+    let api_schema = supergraph
+        .to_api_schema(Default::default())
+        .expect("Expected API schema generation to succeed");
+    let find_input = coord!(FindInput)
+        .lookup(api_schema.schema())
+        .expect("FindInput should exist");
+    assert_snapshot!(find_input, @r"
+    input FindInput @oneOf {
+      id: ID
+      name: String
+    }
+    ");
+}
+
+#[test]
+fn one_of_input_object_errors_when_inconsistent() {
+    let subgraph_a = ServiceDefinition {
+        name: "subgraphA",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let subgraph_b = ServiceDefinition {
+        name: "subgraphB",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let result = compose_as_fed2_subgraphs(&[subgraph_a, subgraph_b]);
+    assert_composition_errors(
+        &result,
+        &[(
+            "INPUT_OBJECT_ONE_OF_MISMATCH",
+            r#"Input object type "FindInput" is marked with @oneOf in subgraph "subgraphA" but not in subgraph "subgraphB""#,
+        )],
+    );
+}
+
+#[test]
+fn one_of_input_object_merges_single_subgraph() {
+    let subgraph_a = ServiceDefinition {
+        name: "subgraphA",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let result = compose_as_fed2_subgraphs(&[subgraph_a]);
+    let supergraph = result.expect("Expected composition to succeed");
+    let api_schema = supergraph
+        .to_api_schema(Default::default())
+        .expect("Expected API schema generation to succeed");
+    let find_input = coord!(FindInput)
+        .lookup(api_schema.schema())
+        .expect("FindInput should exist");
+    assert_snapshot!(find_input, @r"
+    input FindInput @oneOf {
+      id: ID
+      name: String
+    }
+    ");
+}
+
+#[test]
+fn one_of_input_object_with_different_fields_across_subgraphs() {
+    let subgraph_a = ServiceDefinition {
+        name: "subgraphA",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          name: String
+        }
+        "#,
+    };
+
+    let subgraph_b = ServiceDefinition {
+        name: "subgraphB",
+        type_defs: r#"
+        type Query {
+          find(input: FindInput!): String @shareable
+        }
+
+        input FindInput @oneOf {
+          id: ID
+          email: String
+        }
+        "#,
+    };
+
+    let result = compose_as_fed2_subgraphs(&[subgraph_a, subgraph_b]);
+    let supergraph = result.expect("Expected composition to succeed");
+    let api_schema = supergraph
+        .to_api_schema(Default::default())
+        .expect("Expected API schema generation to succeed");
+    let find_input = coord!(FindInput)
+        .lookup(api_schema.schema())
+        .expect("FindInput should exist");
+    assert_snapshot!(find_input, @r"
+    input FindInput @oneOf {
+      id: ID
+    }
+    ");
+}