Relay Flatbuffer SchemaLocation

Reviewed By: tyao1

Differential Revision: D94971587

fbshipit-source-id: 6c7a971407c70b49bb1dc335cf5ab42abb30074f

Author: Shashank Kambhampati

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

@@ -250,6 +250,12 @@
             "type": "string"
           }
         },
+        "schemaFlatbuffer": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
         "schemaName": {
           "description": "Schema name, if differs from project name.\nIf schema name is unset, the project name will be used as schema name.",
           "anyOf": [

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

@@ -7,7 +7,9 @@
 
 use std::sync::Arc;
 
+use common::Diagnostic;
 use common::DiagnosticsResult;
+use common::Location;
 use common::PerfLogEvent;
 use fnv::FnvHashMap;
 use relay_config::ProjectName;
@@ -52,49 +54,17 @@ pub fn build_schema(
     )
 }
 
-fn load_flatbuffer_schema(project_config: &ProjectConfig) -> Option<SDLSchema> {
-    let fb_path = match &project_config.schema_location {
-        SchemaLocation::Directory(dir) => {
-            let mut fb_path = dir.clone();
-            let dir_name = fb_path.file_name()?.to_str()?.to_string();
-            fb_path.pop();
-            fb_path.push(format!("{}.flatbuffer", dir_name));
-            fb_path
-        }
-        SchemaLocation::File(file) => file.with_extension("flatbuffer"),
-    };
-    if !fb_path.exists() {
-        return None;
-    }
-    match std::fs::read(&fb_path) {
-        Ok(bytes) => {
-            log::info!(
-                "Loading FlatBuffer schema from {:?} ({} bytes)",
-                fb_path,
-                bytes.len()
-            );
-            Some(build_schema_with_flat_buffer_unchecked(bytes))
-        }
-        Err(e) => {
-            log::warn!(
-                "Failed to read FlatBuffer schema {:?}: {}, falling back to SDL",
-                fb_path,
-                e,
-            );
-            None
-        }
-    }
-}
-
 fn build_schema_impl(
     compiler_state: &CompilerState,
     project_config: &ProjectConfig,
     log_event: &impl PerfLogEvent,
     config: &Config,
     graphql_asts_map: &FnvHashMap<ProjectName, GraphQLAsts>,
 ) -> DiagnosticsResult<Arc<SDLSchema>> {
-    if let Some(schema) = load_flatbuffer_schema(project_config) {
-        return Ok(Arc::new(schema));
+    if let SchemaLocation::FlatbufferFile(fb_path) = &project_config.schema_location {
+        let contents = std::fs::read(config.root_dir.join(fb_path))
+            .map_err(|e| vec![Diagnostic::error(e.to_string(), Location::generated())])?;
+        return Ok(Arc::new(build_schema_with_flat_buffer_unchecked(contents)));
     }
 
     let schema_sources = get_schema_sources(compiler_state, project_config);

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

@@ -401,23 +401,27 @@ impl Config {
         let projects = projects
             .into_iter()
             .map(|(project_name, config_file_project)| {
-                let schema_location =
-                    match (config_file_project.schema, config_file_project.schema_dir) {
-                        (Some(schema_file), None) => Ok(SchemaLocation::File(
-                            normalize_relative_path(&root_dir, &schema_file),
-                        )),
-                        (None, Some(schema_dir)) => Ok(SchemaLocation::Directory(
-                            normalize_relative_path(&root_dir, &schema_dir),
-                        )),
-                        _ => Err(Error::ConfigFileValidation {
-                            config_path: config_path.clone(),
-                            validation_errors: vec![
-                                ConfigValidationError::ProjectNeedsSchemaXorSchemaDir {
-                                    project_name,
-                                },
-                            ],
-                        }),
-                    }?;
+                let schema_location = match (
+                    config_file_project.schema,
+                    config_file_project.schema_dir,
+                    config_file_project.schema_flatbuffer,
+                ) {
+                    (Some(schema_file), None, None) => Ok(SchemaLocation::File(
+                        normalize_relative_path(&root_dir, &schema_file),
+                    )),
+                    (None, Some(schema_dir), None) => Ok(SchemaLocation::Directory(
+                        normalize_relative_path(&root_dir, &schema_dir),
+                    )),
+                    (None, None, Some(schema_flatbuffer)) => Ok(SchemaLocation::FlatbufferFile(
+                        normalize_relative_path(&root_dir, &schema_flatbuffer),
+                    )),
+                    _ => Err(Error::ConfigFileValidation {
+                        config_path: config_path.clone(),
+                        validation_errors: vec![
+                            ConfigValidationError::ProjectNeedsSchemaXorSchemaDir { project_name },
+                        ],
+                    }),
+                }?;
 
                 let shard_strip_regex = config_file_project
                     .shard_strip_regex
@@ -654,7 +658,7 @@ impl Config {
 
         for (_, project) in &self.projects {
             match &project.schema_location {
-                SchemaLocation::File(schema_file) => {
+                SchemaLocation::FlatbufferFile(schema_file) | SchemaLocation::File(schema_file) => {
                     validator.assert_is_included_schema_file(schema_file);
                 }
                 SchemaLocation::Directory(schema_dir) => {
@@ -734,6 +738,7 @@ impl Config {
             .filter_map(|project_config| match &project_config.schema_location {
                 SchemaLocation::File(schema_file) => Some(schema_file.clone()),
                 SchemaLocation::Directory(_) => None,
+                SchemaLocation::FlatbufferFile(schema_file) => Some(schema_file.clone()),
             })
             .collect()
     }
@@ -745,6 +750,7 @@ impl Config {
             .filter_map(|project_config| match &project_config.schema_location {
                 SchemaLocation::File(_) => None,
                 SchemaLocation::Directory(schema_dir) => Some(schema_dir.clone()),
+                SchemaLocation::FlatbufferFile(_) => None,
             })
             .collect()
     }
@@ -1241,6 +1247,7 @@ pub struct ConfigFileProject {
     /// Exactly 1 of these options needs to be defined.
     schema: Option<PathBuf>,
     schema_dir: Option<PathBuf>,
+    schema_flatbuffer: Option<PathBuf>,
 
     /// Schema name, if differs from project name.
     /// If schema name is unset, the project name will be used as schema name.

compiler/crates/relay-compiler/src/file_source/file_categorizer.rs

@@ -179,29 +179,20 @@ impl FileCategorizer {
         }
 
         let mut schema_file_mapping: HashMap<PathBuf, ProjectSet> = Default::default();
-        for (&project_name, project_config) in &config.projects {
-            if let SchemaLocation::File(schema_file) = &project_config.schema_location {
-                match schema_file_mapping.entry(schema_file.clone()) {
-                    Entry::Vacant(entry) => {
-                        entry.insert(ProjectSet::of(project_name));
-                    }
-                    Entry::Occupied(mut entry) => {
-                        entry.get_mut().insert(project_name);
-                    }
-                }
-            }
-        }
-
         let mut schema_dir_mapping_map: HashMap<PathBuf, ProjectSet> = Default::default();
         for (&project_name, project_config) in &config.projects {
-            if let SchemaLocation::Directory(directory) = &project_config.schema_location {
-                match schema_dir_mapping_map.entry(directory.clone()) {
-                    Entry::Vacant(entry) => {
-                        entry.insert(ProjectSet::of(project_name));
-                    }
-                    Entry::Occupied(mut entry) => {
-                        entry.get_mut().insert(project_name);
-                    }
+            match &project_config.schema_location {
+                SchemaLocation::FlatbufferFile(schema_file) | SchemaLocation::File(schema_file) => {
+                    schema_file_mapping
+                        .entry(schema_file.clone())
+                        .and_modify(|project_set| project_set.insert(project_name))
+                        .or_insert_with(|| ProjectSet::of(project_name));
+                }
+                SchemaLocation::Directory(directory) => {
+                    schema_dir_mapping_map
+                        .entry(directory.clone())
+                        .and_modify(|project_set| project_set.insert(project_name))
+                        .or_insert_with(|| ProjectSet::of(project_name));
                 }
             }
         }

compiler/crates/relay-compiler/src/file_source/file_filter.rs

@@ -75,7 +75,9 @@ fn get_extra_roots(config: &Config, enabled_projects: &FnvHashSet<ProjectName>)
             roots.push(output_dir);
         }
         match &project_config.schema_location {
-            SchemaLocation::File(path) | SchemaLocation::Directory(path) => roots.push(path),
+            SchemaLocation::FlatbufferFile(path)
+            | SchemaLocation::File(path)
+            | SchemaLocation::Directory(path) => roots.push(path),
         }
     }
     unify_roots(roots)

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

@@ -84,6 +84,7 @@ pub async fn compile_and_extract_subschema(
         SchemaLocation::Directory(_) => {
             return Err(SubschemaError::DirectorySchemaNotSupported);
         }
+        SchemaLocation::FlatbufferFile(file) => file.clone(),
     };
 
     // Normalize the full schema path relative to root_dir

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

@@ -174,6 +174,8 @@ pub enum SchemaLocation {
     File(PathBuf),
     /// A directory containing multiple schema files.
     Directory(PathBuf),
+    /// A single file containing a Flatbuffer-serialized schema.
+    FlatbufferFile(PathBuf),
 }
 
 pub struct ExtraArtifactsConfig {