[rust] Better support for abstract types (unions and interfaces)

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

@@ -466,7 +466,11 @@ impl fmt::Debug for Config {
         } = self;
 
         fn option_fn_to_string<T>(option: &Option<T>) -> &'static str {
-            if option.is_some() { "Some(Fn)" } else { "None" }
+            if option.is_some() {
+                "Some(Fn)"
+            } else {
+                "None"
+            }
         }
 
         f.debug_struct("Config")
@@ -745,8 +749,8 @@ impl SingleProjectConfigFile {
                 language: self.language.unwrap_or(TypegenLanguage::TypeScript),
                 custom_scalar_types: self.custom_scalars.clone(),
                 eager_es_modules: self.eager_es_modules,
+                future_proof_enums: !self.no_future_proof_enums,
                 flow_typegen: FlowTypegenConfig {
-                    no_future_proof_enums: self.no_future_proof_enums,
                     phase: self.typegen_phase,
                     ..Default::default()
                 },

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

@@ -27,7 +27,7 @@ impl Default for TypegenLanguage {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Default)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct TypegenConfig {
     /// The desired output language, "flow" or "typescript".
@@ -62,6 +62,23 @@ pub struct TypegenConfig {
     #[serde(default)]
     pub use_import_type_syntax: bool,
 
+    /// This option controls whether or not a catch-all entry is added to enum type definitions
+    /// for values that may be added in the future. Enabling this means you will have to update
+    /// your application whenever the GraphQL server schema adds new enum values to prevent it
+    /// from breaking.
+    #[serde(default = "default_future_proofness")]
+    pub future_proof_enums: bool,
+
+    /// Whether to future proof union and interface types by including "%other" as a possible type.
+    #[serde(default = "default_future_proofness")]
+    pub future_proof_abstract_types: bool,
+
+    /// For which types (unions or interfaces) to not write out all possible type names if future
+    /// proof abstract types is set to false. Especially useful for interfaces or unions that may
+    /// have a lot of concrete types, such as Node.
+    #[serde(default)]
+    pub exclude_from_typename_unions: Vec<StringKey>,
+
     /// A map from GraphQL scalar types to a custom JS type, example:
     /// { "Url": "String" }
     #[serde(default)]
@@ -79,18 +96,17 @@ pub struct TypegenConfig {
     /// This option enables emitting es modules artifacts.
     #[serde(default)]
     pub eager_es_modules: bool,
+
+    /// This option controls which emitted files have sorted fields, fragment names,
+    /// and union members. It also controls whether unions with more than one element
+    /// are written with surrounding parentheses.
+    #[serde(default)]
+    pub sort_typegen_items: SortTypegenItemsConfig,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, Copy)]
 #[serde(deny_unknown_fields, tag = "phase")]
 pub struct FlowTypegenConfig {
-    /// This option controls whether or not a catch-all entry is added to enum type definitions
-    /// for values that may be added in the future. Enabling this means you will have to update
-    /// your application whenever the GraphQL server schema adds new enum values to prevent it
-    /// from breaking.
-    #[serde(default)]
-    pub no_future_proof_enums: bool,
-
     pub phase: FlowTypegenPhase,
     #[serde(default)]
     pub rollout: Rollout,
@@ -99,7 +115,6 @@ pub struct FlowTypegenConfig {
 impl Default for FlowTypegenConfig {
     fn default() -> Self {
         Self {
-            no_future_proof_enums: false,
             phase: FlowTypegenPhase::Final,
             rollout: Rollout::default(),
         }
@@ -139,3 +154,40 @@ impl FlowTypegenPhase {
         }
     }
 }
+
+// Custom impl for Default to set future proofness to true when using Default::default().
+impl Default for TypegenConfig {
+    fn default() -> Self {
+        Self {
+            language: TypegenLanguage::default(),
+            enum_module_suffix: None,
+            optional_input_fields: vec![],
+            use_import_type_syntax: false,
+            future_proof_abstract_types: default_future_proofness(),
+            future_proof_enums: default_future_proofness(),
+            exclude_from_typename_unions: vec![],
+            custom_scalar_types: FnvIndexMap::default(),
+            flow_enums: FnvIndexSet::default(),
+            require_custom_scalar_types: false,
+            flow_typegen: FlowTypegenConfig::default(),
+            eager_es_modules: false,
+            sort_typegen_items: SortTypegenItemsConfig::default(),
+        }
+    }
+}
+
+fn default_future_proofness() -> bool {
+    true
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, Default)]
+pub struct SortTypegenItemsConfig {
+    #[serde(default)]
+    pub rollout: Rollout,
+}
+
+impl SortTypegenItemsConfig {
+    pub fn should_sort(&self, rollout_key: StringKey) -> bool {
+        self.rollout.check(rollout_key.lookup())
+    }
+}

compiler/crates/relay-typegen/Cargo.toml

@@ -21,6 +21,8 @@ lazy_static = "1.0"
 relay-config = { path = "../relay-config" }
 relay-transforms = { path = "../relay-transforms" }
 schema = { path = "../schema" }
+serde = { version = "=1.0.126", features = ["derive", "rc"] }
+serde_json = "1.0.68"
 
 [dev-dependencies]
 fixture-tests = { path = "../fixture-tests" }