fix: validate subscription with conditional selections

Adds validation for subscription operations that specify `@skip`/`@include` conditionals on root selections.

See: graphql/graphql-spec#860

Author: dariuszkuc

crates/apollo-compiler/src/executable/mod.rs

@@ -266,6 +266,16 @@ pub(crate) enum BuildError {
         /// Name of the introspection field
         field: Name,
     },
+    #[error(
+        "{} can not specify @skip or @include on root fields",
+        subscription_name_or_anonymous(name)
+    )]
+    SubscriptionUsesConditionalSelection {
+        /// Name of the operation
+        name: Option<Name>,
+        /// Field name that specify @skip or @include directives.
+        field: Name,
+    },
 
     #[error("{0}")]
     ConflictingFieldType(Box<ConflictingFieldType>),

crates/apollo-compiler/src/validation/mod.rs

@@ -340,6 +340,9 @@ impl DiagnosticData {
                 ExecutableBuildError::SubscriptionUsesIntrospection { .. } => {
                     "SubscriptionUsesIntrospection"
                 }
+                ExecutableBuildError::SubscriptionUsesConditionalSelection { .. } => {
+                    "SubscriptionUsesConditionalSelection"
+                }
                 ExecutableBuildError::ConflictingFieldType(_) => "ConflictingFieldType",
                 ExecutableBuildError::ConflictingFieldName(_) => "ConflictingFieldName",
                 ExecutableBuildError::ConflictingFieldArgument(_) => "ConflictingFieldArgument",
@@ -588,6 +591,18 @@ impl DiagnosticData {
                             .to_string())
                     }
                 }
+                ExecutableBuildError::SubscriptionUsesConditionalSelection { name, .. } => {
+                    if let Some(name) = name {
+                        Some(format!(
+                            r#"Subscription "{name}" can not specify @skip or @include on root fields."#
+                        ))
+                    } else {
+                        Some(
+                            "Anonymous Subscription can not specify @skip or @include on root fields."
+                                .to_string(),
+                        )
+                    }
+                }
                 ExecutableBuildError::ConflictingFieldType(inner) => {
                     let ConflictingFieldType {
                         alias,
@@ -841,6 +856,12 @@ impl ToCliReport for DiagnosticData {
                         format_args!("{field} is an introspection field"),
                     );
                 }
+                ExecutableBuildError::SubscriptionUsesConditionalSelection { field, .. } => {
+                    report.with_label_opt(
+                        self.location,
+                        format_args!("{field} specifies @skip or @include condition"),
+                    );
+                }
                 ExecutableBuildError::ConflictingFieldType(inner) => {
                     let ConflictingFieldType {
                         alias,

crates/apollo-compiler/src/validation/operation.rs

@@ -46,6 +46,27 @@ pub(crate) fn validate_subscription(
                 },
             );
         }
+
+        // first rule validates that we only have single selection
+        let has_conditional_field = fields
+            .iter()
+            .find(|field| {
+                field
+                    .field
+                    .directives
+                    .iter()
+                    .any(|d| matches!(d.name.as_str(), "skip" | "include"))
+            })
+            .map(|field| field.field);
+        if let Some(conditional_field) = has_conditional_field {
+            diagnostics.push(
+                conditional_field.location(),
+                executable::BuildError::SubscriptionUsesConditionalSelection {
+                    name: operation.name.clone(),
+                    field: conditional_field.name.clone(),
+                },
+            );
+        }
     }
 }
 

crates/apollo-compiler/tests/validation/operation.rs

@@ -218,3 +218,99 @@ type Product {
         "{errors}"
     );
 }
+
+#[test]
+fn it_validates_subscription_cannot_specify_multiple_fields() {
+    let input = r#"
+subscription MultipleSubs {
+  ticker1
+  ticker2
+}
+
+type Query {
+  hello: String
+}
+
+type Subscription {
+  ticker1: String
+  ticker2: String
+}
+"#;
+
+    let errors = Parser::new()
+        .parse_mixed_validate(input, "schema.graphql")
+        .unwrap_err()
+        .to_string();
+    assert!(
+        errors.contains("subscription `MultipleSubs` can only have one root field"),
+        "{errors}"
+    );
+    assert!(
+        errors.contains("There are 2 root fields: ticker1, ticker2. This is not allowed."),
+        "{errors}"
+    );
+}
+
+#[test]
+fn it_validates_subscription_cannot_select_introspection_fields() {
+    let input = r#"
+subscription IntrospectionSub {
+  __typename
+}
+
+type Query {
+  hello: String
+}
+
+type Subscription {
+  ticker: String
+}
+"#;
+
+    let errors = Parser::new()
+        .parse_mixed_validate(input, "schema.graphql")
+        .unwrap_err()
+        .to_string();
+    assert!(
+        errors.contains(
+            "subscription `IntrospectionSub` can not have an introspection field as a root field"
+        ),
+        "{errors}"
+    );
+    assert!(
+        errors.contains("__typename is an introspection field"),
+        "{errors}"
+    );
+}
+
+#[test]
+fn it_validates_subscription_cannot_select_conditional_fields() {
+    let input = r#"
+subscription ConditionalSub($condition: Boolean = true) {
+  ticker @include(if: $condition)
+}
+
+type Query {
+  hello: String
+}
+
+type Subscription {
+  ticker: String
+}
+"#;
+
+    let errors = Parser::new()
+        .parse_mixed_validate(input, "schema.graphql")
+        .unwrap_err()
+        .to_string();
+    assert!(
+        errors.contains(
+            "subscription `ConditionalSub` can not specify @skip or @include on root fields"
+        ),
+        "{errors}"
+    );
+    assert!(
+        errors.contains("ticker specifies @skip or @include condition"),
+        "{errors}"
+    );
+}