fix: adopt_orphan_extensions + schema extensions + implicit root operation interaction (#907)

Building a schema with the `adopt_orphan_extensions` option enabled yields an error in the following simple case:
```graphql
extend schema { query: Query }

type Query { x: Int }
```

```
Error: duplicate definitions for the `query` root operation type
   ╭─[schema.graphql:2:25]
   │
 2 │         extend schema { query: Query }
   │                         ──────┬─────  
   │                               ╰─────── `query` redefined here
───╯
```

Currently, it accidentally makes the assumption that a schema extension's root operations do not use a default name, which explains why [this test](https://github.com/apollographql/apollo-rs/blob/caf820d86a03db3650149cefe6157442c73d7e50/crates/apollo-compiler/tests/extensions.rs#L5-L10) currently passes but the failing test from [f3f95b8](f3f95b8) did not. This results in the `query` root operation type being added twice - once at the implicit step, and again when the orphan extensions are applied.

In the case that `adopt_orphan_extensions` is enabled, we need to scan the orphan schema extensions for root operations that match the default name and _skip_ the implicit addition step if so, since the extensions will be applied in a subsequent step.

Author: trevor-scheer

crates/apollo-compiler/src/schema/from_ast.rs

@@ -274,12 +274,28 @@ impl SchemaBuilder {
                 // This a macro rather than a closure to generate separate `static`s
                 let schema_def = schema.schema_definition.make_mut();
                 let mut has_implicit_root_operation = false;
-                for (operation_type, root_operation) in [
+                'root_operation_loop: for (operation_type, root_operation) in [
                     (OperationType::Query, &mut schema_def.query),
                     (OperationType::Mutation, &mut schema_def.mutation),
                     (OperationType::Subscription, &mut schema_def.subscription),
                 ] {
                     let name = operation_type.default_type_name();
+                    // If `adopt_orphan_extensions` is enabled, we should scan
+                    // each orphan schema extension for root operations. If we
+                    // see one, we should skip adding that particular implicit
+                    // root operation since the extensions will be applied
+                    // further down.
+                    if adopt_orphan_extensions {
+                        for ext in &orphan_extensions {
+                            for node in &ext.root_operations {
+                                let current_operation_type = node.as_ref().0;
+                                if current_operation_type == operation_type {
+                                    continue 'root_operation_loop;
+                                }
+                            }
+                        }
+                    }
+
                     if schema.types.get(&name).is_some_and(|def| def.is_object()) {
                         *root_operation = Some(name.into());
                         has_implicit_root_operation = true

crates/apollo-compiler/tests/extensions.rs

@@ -34,6 +34,64 @@ fn test_orphan_extensions() {
     schema2.validate().unwrap();
 }
 
+#[test]
+fn test_orphan_extensions_schema_with_default_query_name() {
+    let input = r#"
+        extend schema { query: Query }
+        type Query { x: Int }
+    "#;
+
+    let schema = Schema::builder()
+        .adopt_orphan_extensions()
+        .parse(input, "schema.graphql")
+        .build()
+        .unwrap();
+
+    schema.validate().unwrap();
+}
+
+#[test]
+fn test_orphan_extensions_schema_def_with_extensions() {
+    let input = r#"
+        extend schema { query: Query }
+        extend schema { subscription: S }
+        schema { mutation: Mutation }
+        type Query { x: Int }
+        type Mutation { y: Int }
+        type S { z: Int }
+    "#;
+
+    let schema = Schema::builder()
+        .adopt_orphan_extensions()
+        .parse(input, "schema.graphql")
+        .build()
+        .unwrap();
+
+    schema.validate().unwrap();
+}
+
+#[test]
+fn test_invalid_orphan_extensions_schema_def_with_duplicate_root_operation() {
+    let input = r#"
+        extend schema { query: Query }
+        extend schema { subscription: S }
+        schema { mutation: Mutation, query: AnotherQuery }
+        type Query { x: Int }
+        type Mutation { y: Int }
+        type S { z: Int }
+        type AnotherQuery { a: String }
+    "#;
+
+    let invalid = Schema::builder()
+        .adopt_orphan_extensions()
+        .parse(input, "schema.graphql")
+        .build()
+        .unwrap_err();
+
+    let err = invalid.errors.to_string();
+    assert!(err.contains("duplicate definitions for the `query` root operation type"));
+}
+
 #[test]
 fn test_orphan_extensions_kind_mismatch() {
     let input = r#"