Add support for Typescript in Rust Relay compiler

compiler/crates/relay-compiler/src/build_project/generate_artifacts.rs

@@ -18,6 +18,7 @@ use graphql_text_printer::{
 };
 use graphql_transforms::{RefetchableDerivedFromMetadata, SplitOperationMetaData, MATCH_CONSTANTS};
 use interner::StringKey;
+use relay_typegen::TypegenLanguage;
 use std::path::PathBuf;
 use std::sync::Arc;
 
@@ -60,7 +61,7 @@ pub fn generate_artifacts(
 
             artifacts.push(Artifact {
                 source_definition_names: metadata.parent_sources.into_iter().collect(),
-                path: path_for_js_artifact(
+                path: path_for_artifact(
                     project_config,
                     source_file,
                     normalization_operation.name.item,
@@ -175,7 +176,7 @@ fn generate_normalization_artifact<'a>(
         .expect("a type fragment should be generated for this operation");
     Ok(Artifact {
         source_definition_names: vec![source_definition_name],
-        path: path_for_js_artifact(project_config, source_file, name),
+        path: path_for_artifact(project_config, source_file, name),
         content: ArtifactContent::Operation {
             normalization_operation: Arc::clone(normalization_operation),
             reader_operation: Arc::clone(reader_operation),
@@ -201,7 +202,7 @@ fn generate_reader_artifact(
         .expect("a type fragment should be generated for this fragment");
     Artifact {
         source_definition_names: vec![name],
-        path: path_for_js_artifact(
+        path: path_for_artifact(
             project_config,
             reader_fragment.name.location.source_location(),
             name,
@@ -254,15 +255,18 @@ pub fn create_path_for_artifact(
     }
 }
 
-fn path_for_js_artifact(
+fn path_for_artifact(
     project_config: &ProjectConfig,
     source_file: SourceLocationKey,
     definition_name: StringKey,
 ) -> PathBuf {
     create_path_for_artifact(
         project_config,
         source_file,
-        format!("{}.graphql.js", definition_name),
+        match &project_config.typegen_config.language {
+            TypegenLanguage::Flow => format!("{}.graphql.js", definition_name),
+            TypegenLanguage::Typescript => format!("{}.graphql.ts", definition_name),
+        },
         false,
     )
 }

compiler/crates/relay-compiler/src/watchman/query_builder.rs

@@ -5,22 +5,44 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+use crate::compiler_state::SourceSet;
 use crate::config::{Config, SchemaLocation};
+use relay_typegen::TypegenLanguage;
 use std::path::PathBuf;
 use watchman_client::prelude::*;
 
 pub fn get_watchman_expr(config: &Config) -> Expr {
-    let mut sources_conditions = vec![
-        // ending in *.js
-        Expr::Suffix(vec!["js".into()]),
-        // in one of the source roots
-        expr_any(
-            get_source_roots(&config)
-                .into_iter()
-                .map(|path| Expr::DirName(DirNameTerm { path, depth: None }))
-                .collect(),
-        ),
-    ];
+    let mut sources_conditions = vec![expr_any(
+        config
+            .sources
+            .iter()
+            .flat_map(|(path, name)| match name {
+                SourceSet::SourceSetName(name) => {
+                    std::iter::once((path, config.projects.get(&name))).collect::<Vec<_>>()
+                }
+                SourceSet::SourceSetNames(names) => names
+                    .iter()
+                    .map(|name| (path, config.projects.get(name)))
+                    .collect::<Vec<_>>(),
+            })
+            .filter_map(|(path, project)| match project {
+                Some(p) if p.enabled => Some(Expr::All(vec![
+                    // Ending in *.js or *.ts depending on the project lanague.
+                    Expr::Suffix(vec![match &p.typegen_config.language {
+                        TypegenLanguage::Flow => "js",
+                        TypegenLanguage::Typescript => "ts",
+                    }
+                    .into()]),
+                    // In the related source root.
+                    Expr::DirName(DirNameTerm {
+                        path: path.clone(),
+                        depth: None,
+                    }),
+                ])),
+                _ => None,
+            })
+            .collect(),
+    )];
     // not excluded by any glob
     if !config.excludes.is_empty() {
         sources_conditions.push(Expr::Not(Box::new(expr_any(

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

@@ -9,9 +9,26 @@ use fnv::FnvHashMap;
 use interner::StringKey;
 use serde::Deserialize;
 
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub enum TypegenLanguage {
+    Flow,
+    Typescript,
+}
+
+impl Default for TypegenLanguage {
+    fn default() -> Self {
+        Self::Flow
+    }
+}
+
 #[derive(Debug, Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct TypegenConfig {
+    /// The desired output language, "flow" or "typescript".
+    #[serde(default)]
+    pub language: TypegenLanguage,
+
     /// # For Flow type generation
     /// When set, enum values are imported from a module with this suffix.
     /// For example, an enum Foo and this property set to ".test" would be