refactor: move @OneOf validation to pre_merge_validations

Validates @OneOf consistency across subgraphs before merging begins,
matching the pattern used by other cross-subgraph validations.

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

Author: tninesling

apollo-federation/src/composition/mod.rs

@@ -13,6 +13,7 @@ use crate::connectors::expand::expand_connectors;
 use crate::error::CompositionError;
 use crate::merger::merge::Merger;
 pub use crate::schema::schema_upgrader::upgrade_subgraphs_if_necessary;
+use crate::schema::validators::one_of::validate_one_of_consistency;
 use crate::schema::validators::root_fields::validate_consistent_root_fields;
 use crate::subgraph::typestate::Expanded;
 use crate::subgraph::typestate::Initial;
@@ -136,6 +137,7 @@ pub fn expand_subgraphs(
 #[instrument(skip(subgraphs))]
 pub fn pre_merge_validations(subgraphs: &[Subgraph<Validated>]) -> Result<(), CompositionFailure> {
     validate_consistent_root_fields(subgraphs).map_err(CompositionFailure::from_errors)?;
+    validate_one_of_consistency(subgraphs).map_err(CompositionFailure::from_errors)?;
     // TODO: (FED-713) Implement any pre-merge validations that require knowledge of all subgraphs.
     Ok(())
 }

apollo-federation/src/merger/merge_input.rs

@@ -26,8 +26,6 @@ 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)?;
@@ -278,39 +276,4 @@ 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/schema/validators/mod.rs

@@ -30,6 +30,7 @@ pub(crate) mod interface_object;
 pub(crate) mod key;
 pub(crate) mod list_size;
 pub(crate) mod merged;
+pub(crate) mod one_of;
 pub(crate) mod provides;
 pub(crate) mod requires;
 pub(crate) mod root_fields;

apollo-federation/src/schema/validators/one_of.rs

@@ -0,0 +1,59 @@
+use apollo_compiler::schema::ExtendedType;
+
+use crate::error::CompositionError;
+use crate::subgraph::typestate::HasMetadata;
+use crate::subgraph::typestate::Subgraph;
+use crate::utils::human_readable::human_readable_subgraph_names;
+
+/// Validates that all subgraphs defining the same input object type agree on
+/// whether `@oneOf` is applied. Disagreement would produce an invalid
+/// supergraph, so we reject it before merging.
+pub(crate) fn validate_one_of_consistency<T: HasMetadata>(
+    subgraphs: &[Subgraph<T>],
+) -> Result<(), Vec<CompositionError>> {
+    let mut errors = Vec::new();
+
+    // Collect all input object type names across subgraphs.
+    let mut input_type_names = std::collections::BTreeSet::new();
+    for subgraph in subgraphs {
+        for (name, ty) in &subgraph.schema().schema().types {
+            if matches!(ty, ExtendedType::InputObject(_)) {
+                input_type_names.insert(name.clone());
+            }
+        }
+    }
+
+    for type_name in &input_type_names {
+        let mut with_one_of: Vec<&str> = Vec::new();
+        let mut without_one_of: Vec<&str> = Vec::new();
+
+        for subgraph in subgraphs {
+            if let Some(ExtendedType::InputObject(input_obj)) =
+                subgraph.schema().schema().types.get(type_name)
+            {
+                if input_obj.directives.has("oneOf") {
+                    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());
+            errors.push(CompositionError::InputObjectOneOfMismatch {
+                message: format!(
+                    "Input object type \"{type_name}\" is marked with @oneOf in {with_str} but not in {without_str}",
+                ),
+                locations: Vec::new(),
+            });
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors)
+    }
+}