add config for autoExhaustiveTypes

Author: zth

compiler/crates/relay-compiler/relay-compiler-config-schema.json

@@ -424,6 +424,7 @@ impl Config {
                     persist: config_file_project.persist,
                     variable_names_comment: config_file_project.variable_names_comment,
                     auto_exhaustive_mutations: config_file_project.auto_exhaustive_mutations,
+                    auto_exhaustive_types: config_file_project.auto_exhaustive_types.clone(),
                     test_path_regex,
                     feature_flags: Arc::new(
                         config_file_project
@@ -1218,6 +1219,10 @@ pub struct ConfigFileProject {
     #[serde(default)]
     auto_exhaustive_mutations: bool,
 
+    /// Union/interface types that should be validated exhaustively without adding @exhaustive manually.
+    #[serde(default)]
+    auto_exhaustive_types: Vec<StringKey>,
+
     /// A placeholder for allowing extra information in the config file
     #[serde(default)]
     extra: serde_json::Value,

compiler/crates/relay-compiler/src/config.rs

@@ -297,6 +297,8 @@ pub struct ProjectConfig {
     /// Automatically enforce exhaustive union selections on mutation fields
     /// returning union types.
     pub auto_exhaustive_mutations: bool,
+    /// GraphQL union or interface type names that should always be exhaustively validated.
+    pub auto_exhaustive_types: Vec<StringKey>,
     /// Additional metadata for the project.
     pub extra: serde_json::Value,
     /// Feature flags for the project.
@@ -344,6 +346,7 @@ impl Default for ProjectConfig {
             persist: None,
             variable_names_comment: false,
             auto_exhaustive_mutations: false,
+            auto_exhaustive_types: vec![],
             extra: Default::default(),
             test_path_regex: None,
             rollout: Default::default(),
@@ -379,6 +382,7 @@ impl Debug for ProjectConfig {
             persist,
             variable_names_comment,
             auto_exhaustive_mutations,
+            auto_exhaustive_types,
             extra,
             feature_flags,
             test_path_regex,
@@ -410,6 +414,7 @@ impl Debug for ProjectConfig {
             .field("persist", persist)
             .field("variable_names_comment", variable_names_comment)
             .field("auto_exhaustive_mutations", auto_exhaustive_mutations)
+            .field("auto_exhaustive_types", auto_exhaustive_types)
             .field("extra", extra)
             .field("feature_flags", feature_flags)
             .field("test_path_regex", test_path_regex)

compiler/crates/relay-config/src/project_config.rs

@@ -360,6 +360,13 @@ Marks a field as exhaustive.
 """
 directive @exhaustive(ignore: [String!], disabled: Boolean) on FIELD | FRAGMENT_DEFINITION
 
+"""
+(RescriptRelay only)
+
+Opt out of automatic exhaustive validation for a field or fragment.
+"""
+directive @nonExhaustive on FIELD | FRAGMENT_DEFINITION
+
 """
 (Relay Only)
 

compiler/crates/relay-schema/src/relay-extensions.graphql

@@ -18,6 +18,7 @@ use intern::string_key::Intern;
 use intern::string_key::StringKey;
 use lazy_static::lazy_static;
 use relay_config::ProjectConfig;
+use schema::FieldID;
 use schema::InterfaceID;
 use schema::ObjectID;
 use schema::SDLSchema;
@@ -29,6 +30,8 @@ use crate::ValidationMessage;
 
 lazy_static! {
     pub static ref EXHAUSTIVE_DIRECTIVE_NAME: DirectiveName = DirectiveName("exhaustive".intern());
+    pub static ref NON_EXHAUSTIVE_DIRECTIVE_NAME: DirectiveName =
+        DirectiveName("nonExhaustive".intern());
     pub static ref IGNORE_ARG_NAME: ArgumentName = ArgumentName("ignore".intern());
     pub static ref DISABLED_ARG_NAME: ArgumentName = ArgumentName("disabled".intern());
 }
@@ -52,6 +55,7 @@ struct ExhaustiveDirectiveValidator<'schema, 'program, 'pc> {
     program: &'program Program,
     project_config: &'pc ProjectConfig,
     is_mutation: bool,
+    auto_exhaustive_types: std::collections::HashSet<StringKey>,
     errors: Vec<Diagnostic>,
 }
 
@@ -66,6 +70,11 @@ impl<'schema, 'program, 'pc> ExhaustiveDirectiveValidator<'schema, 'program, 'pc
             program,
             project_config,
             is_mutation: false,
+            auto_exhaustive_types: project_config
+                .auto_exhaustive_types
+                .iter()
+                .copied()
+                .collect(),
             errors: vec![],
         }
     }
@@ -128,9 +137,8 @@ impl<'schema, 'program, 'pc> ExhaustiveDirectiveValidator<'schema, 'program, 'pc
             .recursively_implementing_objects(self.schema.as_ref())
             .into_iter()
             .collect::<Vec<_>>();
-        implementing_objects.sort_by_key(|object_id| {
-            self.schema.get_type_name(Type::Object(*object_id))
-        });
+        implementing_objects
+            .sort_by_key(|object_id| self.schema.get_type_name(Type::Object(*object_id)));
 
         let mut missing_members = Vec::new();
 
@@ -151,18 +159,26 @@ impl<'schema, 'program, 'pc> ExhaustiveDirectiveValidator<'schema, 'program, 'pc
         let mut ignored = std::collections::HashSet::new();
         let mut has_directive = false;
         let mut disabled = false;
+        let has_non_exhaustive = field
+            .directives
+            .named(*NON_EXHAUSTIVE_DIRECTIVE_NAME)
+            .is_some();
 
         if let Some(directive) = field.directives.named(*EXHAUSTIVE_DIRECTIVE_NAME) {
             has_directive = true;
             let (parsed_ignored, parsed_disabled) =
                 Self::parse_exhaustive_directive_args(directive);
             ignored = parsed_ignored;
             disabled = parsed_disabled;
+        } else if has_non_exhaustive {
+            return;
         } else if self.project_config.auto_exhaustive_mutations
             && self.is_mutation
             && self.field_is_top_level_mutation(field)
         {
             has_directive = true;
+        } else if self.field_return_type_is_auto_exhaustive(field.definition.item) {
+            has_directive = true;
         }
 
         if !has_directive || disabled {
@@ -213,13 +229,27 @@ impl<'schema, 'program, 'pc> ExhaustiveDirectiveValidator<'schema, 'program, 'pc
     }
 
     fn validate_exhaustive_fragment(&mut self, fragment: &FragmentDefinition) {
-        let Some(directive) = fragment.directives.named(*EXHAUSTIVE_DIRECTIVE_NAME) else {
-            return;
-        };
+        let mut ignored = std::collections::HashSet::new();
+        let mut disabled = false;
+        let mut has_directive = false;
+        let has_non_exhaustive = fragment
+            .directives
+            .named(*NON_EXHAUSTIVE_DIRECTIVE_NAME)
+            .is_some();
 
-        let (ignored, disabled) = Self::parse_exhaustive_directive_args(directive);
+        if let Some(directive) = fragment.directives.named(*EXHAUSTIVE_DIRECTIVE_NAME) {
+            has_directive = true;
+            let (parsed_ignored, parsed_disabled) =
+                Self::parse_exhaustive_directive_args(directive);
+            ignored = parsed_ignored;
+            disabled = parsed_disabled;
+        } else if has_non_exhaustive {
+            return;
+        } else if self.type_is_auto_exhaustive(fragment.type_condition) {
+            has_directive = true;
+        }
 
-        if disabled {
+        if !has_directive || disabled {
             return;
         }
 
@@ -321,6 +351,26 @@ impl<'schema, 'program, 'pc> ExhaustiveDirectiveValidator<'schema, 'program, 'pc
             _ => false,
         }
     }
+
+    fn type_is_auto_exhaustive(&self, type_: Type) -> bool {
+        let Some(type_name) = self.get_auto_exhaustive_type_name(type_) else {
+            return false;
+        };
+        self.auto_exhaustive_types.contains(&type_name)
+    }
+
+    fn field_return_type_is_auto_exhaustive(&self, field_id: FieldID) -> bool {
+        let return_type = self.schema.field(field_id).type_.inner();
+        self.type_is_auto_exhaustive(return_type)
+    }
+
+    fn get_auto_exhaustive_type_name(&self, type_: Type) -> Option<StringKey> {
+        match type_ {
+            Type::Union(id) => Some(self.schema.get_type_name(Type::Union(id))),
+            Type::Interface(id) => Some(self.schema.get_type_name(Type::Interface(id))),
+            _ => None,
+        }
+    }
 }
 
 impl Validator for ExhaustiveDirectiveValidator<'_, '_, '_> {

compiler/crates/relay-transforms/src/validations/validate_exhaustive_directive.rs

@@ -7,13 +7,20 @@
 
 use fixture_tests::Fixture;
 use graphql_test_helpers::apply_transform_for_test;
+use intern::string_key::Intern;
 use relay_config::ProjectConfig;
 use relay_transforms::validate_exhaustive_directive;
 
 pub async fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String> {
     apply_transform_for_test(fixture, |program| {
+        let auto_exhaustive_types = if fixture.file_name.contains("auto-type") {
+            vec!["UserNameRenderer".intern()]
+        } else {
+            vec![]
+        };
         let project_config = ProjectConfig {
             auto_exhaustive_mutations: true,
+            auto_exhaustive_types,
             ..Default::default()
         };
         validate_exhaustive_directive(program, &project_config)?;

compiler/crates/relay-transforms/tests/validate_exhaustive_directive.rs

@@ -0,0 +1,19 @@
+==================================== INPUT ====================================
+#expected-to-throw
+query AutoTypeMissing {
+  me {
+    nameRenderer {
+      ... on PlainUserNameRenderer { __typename }
+      ... on MarkdownUserNameRenderer { __typename }
+    }
+  }
+}
+==================================== ERROR ====================================
+✖︎ Field 'nameRenderer' marked with @exhaustive is missing selection for union members: 'CustomNameRenderer'.
+
+  auto-type-missing.invalid.graphql:4:5
+    2 │ query AutoTypeMissing {
+    3 │   me {
+    4 │     nameRenderer {
+      │     ^^^^^^^^^^^^
+    5 │       ... on PlainUserNameRenderer { __typename }

compiler/crates/relay-transforms/tests/validate_exhaustive_directive/fixtures/auto-type-missing.invalid.expected

@@ -0,0 +1,9 @@
+#expected-to-throw
+query AutoTypeMissing {
+  me {
+    nameRenderer {
+      ... on PlainUserNameRenderer { __typename }
+      ... on MarkdownUserNameRenderer { __typename }
+    }
+  }
+}

compiler/crates/relay-transforms/tests/validate_exhaustive_directive/fixtures/auto-type-missing.invalid.graphql

@@ -0,0 +1,16 @@
+==================================== INPUT ====================================
+query AutoTypeNonExhaustive {
+  me {
+    nameRenderer @nonExhaustive {
+      ... on PlainUserNameRenderer { __typename }
+    }
+  }
+}
+==================================== OUTPUT ===================================
+query AutoTypeNonExhaustive {
+  me {
+    nameRenderer @nonExhaustive {
+      ... on PlainUserNameRenderer { __typename }
+    }
+  }
+}

compiler/crates/relay-transforms/tests/validate_exhaustive_directive/fixtures/auto-type-non-exhaustive.expected

@@ -0,0 +1,7 @@
+query AutoTypeNonExhaustive {
+  me {
+    nameRenderer @nonExhaustive {
+      ... on PlainUserNameRenderer { __typename }
+    }
+  }
+}