Refactoring of the type generation/type assertion for provided variables to support internal use case with shared artifacts.

Differential Revision: D48801823

fbshipit-source-id: a556107a34b040935bb7c9d417492e4a031e5d90

Author: alunyov

compiler/crates/relay-codegen/src/build_ast.rs

@@ -75,16 +75,15 @@ use crate::ast::QueryID;
 use crate::ast::RequestParameters;
 use crate::constants::CODEGEN_CONSTANTS;
 use crate::object;
-use crate::top_level_statements::TopLevelStatements;
 
 pub fn build_request_params_ast_key(
     schema: &SDLSchema,
     request_parameters: RequestParameters<'_>,
     ast_builder: &mut AstBuilder,
     operation: &OperationDefinition,
-    top_level_statements: &TopLevelStatements,
     definition_source_location: WithLocation<StringKey>,
     project_config: &ProjectConfig,
+    maybe_provided_variables: Option<AstKey>,
 ) -> AstKey {
     let mut operation_builder = CodegenBuilder::new(
         schema,
@@ -93,7 +92,11 @@ pub fn build_request_params_ast_key(
         project_config,
         definition_source_location,
     );
-    operation_builder.build_request_parameters(operation, request_parameters, top_level_statements)
+    operation_builder.build_request_parameters(
+        operation,
+        request_parameters,
+        maybe_provided_variables,
+    )
 }
 
 pub fn build_provided_variables(
@@ -1837,7 +1840,7 @@ impl<'schema, 'builder, 'config> CodegenBuilder<'schema, 'builder, 'config> {
         &mut self,
         operation: &OperationDefinition,
         request_parameters: RequestParameters<'_>,
-        top_level_statements: &TopLevelStatements,
+        maybe_provided_variables: Option<AstKey>,
     ) -> AstKey {
         let mut metadata_items: Vec<ObjectEntry> = operation
             .directives
@@ -1926,20 +1929,10 @@ impl<'schema, 'builder, 'config> CodegenBuilder<'schema, 'builder, 'config> {
             },
         });
 
-        let provided_variables = if top_level_statements
-            .contains(CODEGEN_CONSTANTS.provided_variables_definition.lookup())
-        {
-            Some(Primitive::Variable(
-                CODEGEN_CONSTANTS.provided_variables_definition,
-            ))
-        } else {
-            self.build_operation_provided_variables(operation)
-                .map(Primitive::Key)
-        };
-        if let Some(value) = provided_variables {
+        if let Some(provided_variables) = maybe_provided_variables {
             params_object.push(ObjectEntry {
                 key: CODEGEN_CONSTANTS.provided_variables,
-                value,
+                value: Primitive::Key(provided_variables),
             });
         }
 

compiler/crates/relay-codegen/src/constants.rs

@@ -90,7 +90,6 @@ pub struct CodegenConstants {
     pub passing_value: StringKey,
     pub path: StringKey,
     pub plural: StringKey,
-    pub provided_variables_definition: StringKey,
     pub provided_variables: StringKey,
     pub provider: StringKey,
     pub query: StringKey,
@@ -200,7 +199,6 @@ lazy_static! {
         passing_value: "passingValue".intern(),
         path: "path".intern(),
         plural: "plural".intern(),
-        provided_variables_definition: "providedVariablesDefinition".intern(),
         provided_variables: "providedVariables".intern(),
         provider: "provider".intern(),
         query: "query".intern(),

compiler/crates/relay-codegen/src/lib.rs

@@ -28,6 +28,7 @@ pub use build_ast::CodegenVariant;
 pub use constants::CODEGEN_CONSTANTS;
 pub use printer::print_fragment;
 pub use printer::print_operation;
+pub use printer::print_provided_variables;
 pub use printer::print_request;
 pub use printer::print_request_params;
 pub use printer::JSONPrinter;

compiler/crates/relay-codegen/src/printer.rs

@@ -75,13 +75,15 @@ pub fn print_request(
     request_parameters: RequestParameters<'_>,
     project_config: &ProjectConfig,
     top_level_statements: &mut TopLevelStatements,
+    maybe_provided_variables: Option<AstKey>,
 ) -> String {
     Printer::without_dedupe(project_config).print_request(
         schema,
         operation,
         fragment,
         request_parameters,
         top_level_statements,
+        maybe_provided_variables,
     )
 }
 
@@ -94,21 +96,45 @@ pub fn print_request_params(
 ) -> String {
     let mut request_parameters = build_request_params(operation);
     request_parameters.id = query_id;
-
     let mut builder = AstBuilder::default();
+    let maybe_provided_variables = build_provided_variables(
+        schema,
+        &mut builder,
+        operation,
+        operation.name.map(|x| x.0),
+        project_config,
+    );
     let request_parameters_ast_key = build_request_params_ast_key(
         schema,
         request_parameters,
         &mut builder,
         operation,
-        top_level_statements,
         operation.name.map(|x| x.0),
         project_config,
+        maybe_provided_variables,
     );
     let printer = JSONPrinter::new(&builder, project_config, top_level_statements);
     printer.print(request_parameters_ast_key, false)
 }
 
+pub fn print_provided_variables(
+    schema: &SDLSchema,
+    operation: &OperationDefinition,
+    project_config: &ProjectConfig,
+) -> Option<String> {
+    let mut top_level_statements = Default::default();
+    let mut builder = AstBuilder::default();
+    let maybe_provided_variables = build_provided_variables(
+        schema,
+        &mut builder,
+        operation,
+        operation.name.map(|x| x.0),
+        project_config,
+    )?;
+    let printer = JSONPrinter::new(&builder, project_config, &mut top_level_statements);
+    Some(printer.print(maybe_provided_variables, false))
+}
+
 pub struct Printer<'p> {
     project_config: &'p ProjectConfig,
     builder: AstBuilder,
@@ -132,21 +158,27 @@ impl<'p> Printer<'p> {
         }
     }
 
-    pub fn print_provided_variables(
+    pub fn prepare_provided_variables_object(
         &mut self,
         schema: &SDLSchema,
         operation: &OperationDefinition,
-        top_level_statements: &mut TopLevelStatements,
-    ) -> Option<String> {
-        let key = build_provided_variables(
+    ) -> Option<AstKey> {
+        build_provided_variables(
             schema,
             &mut self.builder,
             operation,
             operation.name.map(|x| x.0),
             self.project_config,
-        )?;
+        )
+    }
+
+    pub fn print_provided_variables(
+        &mut self,
+        provided_variables: AstKey,
+        top_level_statements: &mut TopLevelStatements,
+    ) -> Option<String> {
         let printer = JSONPrinter::new(&self.builder, self.project_config, top_level_statements);
-        Some(printer.print(key, self.dedupe))
+        Some(printer.print(provided_variables, self.dedupe))
     }
 
     pub fn print_updatable_query(
@@ -183,15 +215,16 @@ impl<'p> Printer<'p> {
         fragment: &FragmentDefinition,
         request_parameters: RequestParameters<'_>,
         top_level_statements: &mut TopLevelStatements,
+        maybe_provided_variables: Option<AstKey>,
     ) -> String {
         let request_parameters = build_request_params_ast_key(
             schema,
             request_parameters,
             &mut self.builder,
             operation,
-            top_level_statements,
             operation.name.map(|x| x.0),
             self.project_config,
+            maybe_provided_variables,
         );
 
         let key = build_request(
@@ -247,15 +280,16 @@ impl<'p> Printer<'p> {
         request_parameters: RequestParameters<'_>,
         operation: &OperationDefinition,
         top_level_statements: &mut TopLevelStatements,
+        maybe_provided_variables: Option<AstKey>,
     ) -> String {
         let key = build_request_params_ast_key(
             schema,
             request_parameters,
             &mut self.builder,
             operation,
-            top_level_statements,
             operation.name.map(|x| x.0),
             self.project_config,
+            maybe_provided_variables,
         );
         let printer = JSONPrinter::new(&self.builder, self.project_config, top_level_statements);
         printer.print(key, self.dedupe)

compiler/crates/relay-compiler/src/artifact_content/content.rs

@@ -14,12 +14,9 @@ use common::NamedItem;
 use graphql_ir::FragmentDefinition;
 use graphql_ir::FragmentDefinitionName;
 use graphql_ir::OperationDefinition;
-use intern::Lookup;
 use relay_codegen::build_request_params;
 use relay_codegen::Printer;
 use relay_codegen::QueryID;
-use relay_codegen::TopLevelStatement;
-use relay_codegen::CODEGEN_CONSTANTS;
 use relay_transforms::is_operation_preloadable;
 use relay_transforms::RelayDataDrivenDependencyMetadata;
 use relay_transforms::ASSIGNABLE_DIRECTIVE;
@@ -111,6 +108,7 @@ pub fn generate_updatable_query(
                 schema,
                 project_config,
                 fragment_locations,
+                None, // TODO: Add/investigrate support for provided variables in updatable queries
             )
         )?;
     }
@@ -129,7 +127,7 @@ pub fn generate_updatable_query(
         &project_config.typegen_config.language,
         &mut section,
         "node",
-        generated_types.ast_type,
+        Some(generated_types.ast_type),
         &request,
     )?;
     content_sections.push(ContentSection::Generic(section));
@@ -264,7 +262,16 @@ pub fn generate_operation(
         "relay-runtime",
     )?;
 
+    // -- Generate provided variables --
+    let mut top_level_statements = Default::default();
+    let maybe_provided_variables =
+        printer.prepare_provided_variables_object(schema, normalization_operation);
+
     if !skip_types {
+        let provided_variables_text = maybe_provided_variables.and_then(|provided_variables| {
+            printer.print_provided_variables(provided_variables, &mut top_level_statements)
+        });
+
         write!(
             section,
             "{}",
@@ -274,6 +281,7 @@ pub fn generate_operation(
                 schema,
                 project_config,
                 fragment_locations,
+                provided_variables_text,
             )
         )?;
     }
@@ -286,44 +294,26 @@ pub fn generate_operation(
 
     // -- Begin Top Level Statements Section --
     let mut section = GenericSection::default();
-    let mut top_level_statements = Default::default();
-    if let Some(provided_variables) =
-        printer.print_provided_variables(schema, normalization_operation, &mut top_level_statements)
-    {
-        let mut provided_variable_text = String::new();
-        write_variable_value_with_type(
-            &project_config.typegen_config.language,
-            &mut provided_variable_text,
-            CODEGEN_CONSTANTS.provided_variables_definition.lookup(),
-            relay_typegen::PROVIDED_VARIABLE_TYPE,
-            &provided_variables,
-        )
-        .unwrap();
-        top_level_statements.insert(
-            CODEGEN_CONSTANTS.provided_variables_definition.to_string(),
-            TopLevelStatement::VariableDefinition(provided_variable_text),
-        );
-    }
+    write!(section, "{}", &top_level_statements)?;
+    content_sections.push(ContentSection::Generic(section));
+    // -- End Top Level Statements Section --
 
+    // -- Begin Query Node Section --
     let request = printer.print_request(
         schema,
         normalization_operation,
         &operation_fragment,
         request_parameters,
         &mut top_level_statements,
+        maybe_provided_variables,
     );
 
-    write!(section, "{}", &top_level_statements)?;
-    content_sections.push(ContentSection::Generic(section));
-    // -- End Top Level Statements Section --
-
-    // -- Begin Query Node Section --
     let mut section = GenericSection::default();
     write_variable_value_with_type(
         &project_config.typegen_config.language,
         &mut section,
         "node",
-        generated_types.ast_type,
+        Some(generated_types.ast_type),
         &request,
     )?;
     content_sections.push(ContentSection::Generic(section));
@@ -469,7 +459,7 @@ pub fn generate_split_operation(
         &project_config.typegen_config.language,
         &mut section,
         "node",
-        "NormalizationSplitOperation",
+        Some("NormalizationSplitOperation"),
         &operation,
     )?;
     content_sections.push(ContentSection::Generic(section));
@@ -631,7 +621,7 @@ fn generate_read_only_fragment(
         &project_config.typegen_config.language,
         &mut section,
         "node",
-        generated_types.ast_type,
+        Some(generated_types.ast_type),
         &fragment,
     )?;
     content_sections.push(ContentSection::Generic(section));
@@ -726,7 +716,7 @@ fn generate_assignable_fragment(
         &project_config.typegen_config.language,
         &mut section,
         "node",
-        "any",
+        Some("any"),
         "{}",
     )?;
     content_sections.push(ContentSection::Generic(section));
@@ -774,17 +764,17 @@ fn write_variable_value_with_type(
     language: &TypegenLanguage,
     section: &mut dyn Write,
     variable_name: &str,
-    type_: &str,
+    type_: Option<&str>,
     value: &str,
 ) -> FmtResult {
-    match language {
-        TypegenLanguage::JavaScript => writeln!(section, "var {} = {};", variable_name, value),
-        TypegenLanguage::Flow => {
+    match (language, type_) {
+        (TypegenLanguage::Flow, Some(type_)) => {
             writeln!(section, "var {}/*: {}*/ = {};", variable_name, type_, value)
         }
-        TypegenLanguage::TypeScript => {
+        (TypegenLanguage::TypeScript, Some(type_)) => {
             writeln!(section, "const {}: {} = {};", variable_name, type_, value)
         }
+        (_, _) => writeln!(section, "var {} = {};", variable_name, value),
     }
 }
 

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

@@ -85,10 +85,10 @@ impl Writer for FlowPrinter {
         "FragmentType"
     }
 
-    fn write_local_type(&mut self, name: &str, value: &AST) -> FmtResult {
-        write!(&mut self.result, "type {} = ", name)?;
+    fn write_type_assertion(&mut self, name: &str, value: &AST) -> FmtResult {
+        write!(&mut self.result, "({}: ", name)?;
         self.write(value)?;
-        writeln!(&mut self.result, ";")
+        writeln!(&mut self.result, ");")
     }
 
     fn write_export_type(&mut self, name: &str, value: &AST) -> FmtResult {

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

@@ -35,7 +35,7 @@ impl Writer for JavaScriptPrinter {
         ""
     }
 
-    fn write_local_type(&mut self, _name: &str, _value: &AST) -> FmtResult {
+    fn write_type_assertion(&mut self, _name: &str, _value: &AST) -> FmtResult {
         Ok(())
     }