fix: Node<SchemaDefinition>::to_ast method to handle orphan extensions (#984)

Author: duckki

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

@@ -44,7 +44,19 @@ impl Node<SchemaDefinition> {
             subscription,
         } = &**self;
         let extensions = self.extensions();
-        let implict = description.is_none()
+        let root_ops = |ext: Option<&ExtensionId>| -> Vec<Node<(OperationType, Name)>> {
+            self.iter_root_operations()
+                .filter(|(_, op)| op.origin.extension_id() == ext)
+                .map(|(ty, op)| (ty, op.name.clone()).into())
+                .collect()
+        };
+        let orphan_extensions = root_ops(None).is_empty();
+        let implicit = if orphan_extensions {
+            // The schema definition's root operations are all in extensions. That means the orphan
+            // extension was enabled and the schema definition was implicit.
+            true
+        } else {
+            description.is_none()
             && directives.is_empty()
             && extensions.is_empty()
             && [
@@ -54,7 +66,7 @@ impl Node<SchemaDefinition> {
             ]
             .into_iter()
             .all(|(root_operation, operation_type)| {
-                // If there were no explict `schema` definition,
+                // If there were no explicit `schema` definition,
                 // what implicit root operation would we get for this operation type?
                 let default_type_name = operation_type.default_type_name();
                 let has_object = types
@@ -71,14 +83,9 @@ impl Node<SchemaDefinition> {
             // This can be removed after that validation rule is ported to high-level `Schema`.
             && [query, mutation, subscription]
                 .into_iter()
-                .any(|op| op.is_some());
-        let root_ops = |ext: Option<&ExtensionId>| -> Vec<Node<(OperationType, Name)>> {
-            self.iter_root_operations()
-                .filter(|(_, op)| op.origin.extension_id() == ext)
-                .map(|(ty, op)| (ty, op.name.clone()).into())
-                .collect()
+                .any(|op| op.is_some())
         };
-        if implict {
+        if implicit {
             None
         } else {
             Some(ast::Definition::SchemaDefinition(self.same_location(

crates/apollo-compiler/tests/extensions.rs

@@ -1,11 +1,30 @@
 use apollo_compiler::Schema;
 
+fn validate_schema(schema: Schema) {
+    let validated_schema = schema.validate().unwrap();
+
+    // Test the `Schema::to_string()` with orphan extensions by parsing and validating the printed
+    // schema.
+    let printed_schema = validated_schema.to_string();
+    Schema::builder()
+        .adopt_orphan_extensions()
+        .parse(printed_schema, "printed_schema.graphql")
+        .build()
+        .unwrap()
+        .validate()
+        .unwrap();
+}
+
 #[test]
 fn test_orphan_extensions() {
     let input = r#"
         extend schema @dir { query: Q }
         extend type Obj @dir { foo: String }
-        directive @dir on SCHEMA | OBJECT
+        extend interface I @dir { foo: String }
+        extend union U @dir = Obj
+        extend enum E @dir { FOO, BAR }
+        extend input Input @dir { bar: String }
+        directive @dir on SCHEMA | SCALAR | OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT
         type Q { x: Int }
     "#;
 
@@ -31,7 +50,7 @@ fn test_orphan_extensions() {
         .unwrap();
     assert!(schema2.schema_definition.directives.has("dir"));
     assert!(schema2.types["Obj"].directives().has("dir"));
-    schema2.validate().unwrap();
+    validate_schema(schema2);
 }
 
 #[test]
@@ -47,7 +66,7 @@ fn test_orphan_extensions_schema_with_default_query_name() {
         .build()
         .unwrap();
 
-    schema.validate().unwrap();
+    validate_schema(schema);
 }
 
 #[test]
@@ -67,7 +86,7 @@ fn test_orphan_extensions_schema_def_with_extensions() {
         .build()
         .unwrap();
 
-    schema.validate().unwrap();
+    validate_schema(schema);
 }
 
 #[test]
@@ -108,7 +127,7 @@ fn test_orphan_schema_extension_with_root_type_disables_implicit_root_types() {
         .unwrap();
 
     assert!(schema.schema_definition.mutation.is_none());
-    schema.validate().unwrap();
+    validate_schema(schema);
 }
 
 #[test]
@@ -126,7 +145,25 @@ fn test_orphan_schema_extension_without_root_type_enables_implicit_root_types()
         .unwrap();
 
     assert!(schema.schema_definition.query.is_some());
-    schema.validate().unwrap();
+    validate_schema(schema);
+}
+
+#[test]
+fn test_orphan_schema_extension_with_directive_application() {
+    let input = r#"
+        directive @something on SCHEMA
+        extend schema @something { query: Query }
+        type Query { field: Int }
+    "#;
+
+    let schema = Schema::builder()
+        .adopt_orphan_extensions()
+        .parse(input, "schema.graphql")
+        .build()
+        .unwrap();
+
+    assert!(schema.schema_definition.query.is_some());
+    validate_schema(schema);
 }
 
 #[test]