diff --git a/compiler/Cargo.lock b/compiler/Cargo.lock index 1d9644162cc1a..562be9c75ac6e 100644 --- a/compiler/Cargo.lock +++ b/compiler/Cargo.lock @@ -2159,6 +2159,7 @@ dependencies = [ "relay-test-schema", "relay-transforms", "schema", + "serde_json", "tokio", ] diff --git a/compiler/crates/relay-typegen/Cargo.toml b/compiler/crates/relay-typegen/Cargo.toml index 5f932463703a8..0b14ae42843c8 100644 --- a/compiler/crates/relay-typegen/Cargo.toml +++ b/compiler/crates/relay-typegen/Cargo.toml @@ -13,6 +13,7 @@ name = "generate_flow_test_with_custom_id" path = "tests/generate_flow_with_custom_id_test.rs" [dependencies] +serde_json = "1.0.140" common = { path = "../common" } docblock-shared = { path = "../docblock-shared" } fnv = "1.0" diff --git a/compiler/crates/relay-typegen/src/lib.rs b/compiler/crates/relay-typegen/src/lib.rs index c0e3ff4589a1a..52a91824fde2b 100644 --- a/compiler/crates/relay-typegen/src/lib.rs +++ b/compiler/crates/relay-typegen/src/lib.rs @@ -348,3 +348,5 @@ struct TypegenOptions { // Some extra artifacts require special type generation is_extra_artifact_branch_module: bool, } + +mod rescript_conversion; diff --git a/compiler/crates/relay-typegen/src/rescript.rs b/compiler/crates/relay-typegen/src/rescript.rs index 62aa0b7e9039a..115179c5c4726 100644 --- a/compiler/crates/relay-typegen/src/rescript.rs +++ b/compiler/crates/relay-typegen/src/rescript.rs @@ -9,7 +9,6 @@ use std::fmt::Result; use std::fmt::Write; use common::rescript_utils::get_module_name_from_file_path; -use fnv::FnvHashMap; use fnv::FnvHashSet; use graphql_ir::FragmentDefinition; use graphql_ir::OperationDefinition; @@ -41,6 +40,7 @@ pub enum TopLevelFragmentType { ResultWithUnion(Union), ArrayWithObject(Object), ArrayWithResult(Object), + ArrayWithResultUnion(Union), ArrayWithUnion(Union), } @@ -144,7 +144,7 @@ fn ast_to_prop_value( key: &String, optional: bool, found_in_union: bool, - found_in_array: bool, + list_depth: usize, context: &Context, is_from_result: bool, ) -> Option { @@ -174,7 +174,7 @@ fn ast_to_prop_value( // in its underlying form, a data id. So, this little weird thing // handles that. if context == &Context::Variables - && found_in_array + && list_depth > 0 && current_path.len() == 1 // Path length on 1 means that we're on the top level && state .operation_meta_data @@ -202,7 +202,7 @@ fn ast_to_prop_value( key, is_nullable, found_in_union, - found_in_array, + list_depth, context, true, ); @@ -260,6 +260,11 @@ fn ast_to_prop_value( prop_type: Box::new(PropType::StringLiteral(literal.to_string())), }), AST::ReadOnlyArray(ast) => { + state.conversion_instructions.push(InstructionContainer { + context: context.clone(), + at_path: new_at_path.clone(), + instruction: ConverterInstructions::ListDepth(list_depth + 1), + }); // We know that this is a list, and we know // if it's nullable or not. Time to figure // out what it contains! @@ -273,7 +278,7 @@ fn ast_to_prop_value( // or not. false, found_in_union, - true, + list_depth + 1, context, is_from_result, ) { @@ -406,7 +411,7 @@ fn ast_to_prop_value( at_path: new_at_path, instruction: ConverterInstructions::ConvertCustomField( identifier.to_string(), - found_in_array, + list_depth > 0, ), }); is_custom_scalar_that_needs_conversion = true; @@ -421,7 +426,7 @@ fn ast_to_prop_value( context: context.clone(), at_path: new_at_path, instruction: ConverterInstructions::BlockTraversal( - found_in_array, + list_depth > 0, ), }); } @@ -596,7 +601,7 @@ fn get_object_props( &key, false, found_in_union, - false, + 0, context, false, ) @@ -678,7 +683,7 @@ fn get_object_props( &key, key_value_pair.optional, found_in_union, - false, + 0, context, false, ) @@ -870,7 +875,12 @@ fn write_suppress_dead_code_warning_annotation(str: &mut String, indentation: us writeln!(str, "@live") } -fn write_enum_util_functions(state: &ReScriptPrinter, str: &mut String, indentation: usize, full_enum: &FullEnum) -> Result { +fn write_enum_util_functions( + state: &ReScriptPrinter, + str: &mut String, + indentation: usize, + full_enum: &FullEnum, +) -> Result { let name_uncapitalized = uncapitalize_string(&full_enum.name); // First, we write toString functions, that are essentially type casts. This // is fine because we're sure the underlying type is a string, if it made it @@ -1031,234 +1041,73 @@ fn write_union_definition( Ok(()) } -fn write_instruction_json_object( - str: &mut String, - key: &String, - instructions: &Vec<&InstructionContainer>, -) -> Result { - write!(str, "\"{}\":{{", key).unwrap(); - - // Move all instructions into a hash map by path. - let mut by_path = FnvHashMap::default(); - - instructions.iter().for_each(|instruction_container| { - let path_name = conversion_instruction_path_to_name(&instruction_container.at_path); - match by_path.get_mut(&path_name) { - None => { - by_path.insert( - conversion_instruction_path_to_name(&instruction_container.at_path), - vec![instruction_container.instruction.clone()], - ); - () - } - Some(existing_instructions) => { - existing_instructions.push(instruction_container.instruction.clone()) - } - } - }); - - let num_by_path = by_path.len(); - - by_path - .iter() - .sorted_by(|(path_a, _), (path_b, _)| path_b.cmp(&path_a)) - .enumerate() - .for_each(|(index, (path_name, instructions))| { - write!(str, "\"{}\":{{", path_name).unwrap(); - - let mut has_printed_keys = FnvHashSet::default(); - - let num_instructions = instructions.len(); - - instructions - .iter() - .sorted_by(|instr_a, instr_b| { - let (key_a, _) = instruction_to_key_value_pair(&instr_a); - let (key_b, _) = instruction_to_key_value_pair(&instr_b); - - key_b.cmp(&key_a) - }) - .enumerate() - .for_each(|(index, instruction)| { - let (key, value) = instruction_to_key_value_pair(&instruction); - - if has_printed_keys.contains(&key) { - return; - } - - write!(str, "\"{}\":\"{}\"", key, value).unwrap(); - - if num_instructions != index + 1 { - write!(str, ",").unwrap(); - } - - has_printed_keys.insert(key); - }); - - // Close this instruction - write!(str, "}}").unwrap(); - - if num_by_path != index + 1 { - write!(str, ",").unwrap(); - } - }); - - // Close this instruction - write!(str, "}}").unwrap(); - - Ok(()) -} - -// This produces the conversion instructions JSON object. +// Preserve field boundaries and list depth; preparation happens at module load. fn get_conversion_instructions( state: &Box, conversion_instructions: &Vec<&InstructionContainer>, root_object_names: Vec<&String>, root_name: &String, -) -> String { - if conversion_instructions.len() == 0 { - String::from("{}") - } else { - let mut str = String::from("{"); - - // Print any root objects - root_object_names.iter().for_each(|name| { - write_instruction_json_object( - &mut str, - name, - &state - .conversion_instructions - .iter() - .filter( - |instruction_container| match &instruction_container.context { - Context::RootObject(root_object_name) => { - root_object_name.to_string() == name.to_string() - } - _ => false, - }, - ) - .collect_vec(), - ) - .unwrap(); - write!(str, ",").unwrap(); - }); - - // Write the root itself - write_instruction_json_object( - &mut str, - &String::from("__root"), - // The conversion instructions might contain root objects in - // addition to the top level, so we need to get rid of everything - // that doesn't the top level path prefix we're after. - &conversion_instructions - .into_iter() - .filter_map(|instruction_container| { - if instruction_container.at_path[0] == root_name.as_str() { - Some(instruction_container.to_owned()) - } else { - None - } - }) - .collect_vec(), - ) - .unwrap(); - - // Close full obj - write!(str, "}}").unwrap(); - - str + callbacks: &crate::rescript_conversion::CallbackSlots, +) -> crate::rescript_conversion::ConversionPlan { + let mut roots = vec![]; + for name in root_object_names { + let instructions = state.conversion_instructions.iter().filter(|instruction| { + matches!(&instruction.context, Context::RootObject(root) if root == name) + }).collect_vec(); + roots.push((name.to_string(), instructions)); } + roots.push(( + String::from("__root"), + conversion_instructions + .iter() + .filter(|instruction| &instruction.at_path[0] == root_name) + .copied() + .collect_vec(), + )); + crate::rescript_conversion::write_plan(roots, callbacks) } -// This writes the converter map, used to convert things like custom scalars and -// unions. -fn write_converter_map( +// Write the callback table indexed by the IDs stored in the conversion plan. +fn write_callbacks( str: &mut String, indentation: usize, - instructions: &Vec<&InstructionContainer>, + callbacks: &crate::rescript_conversion::CallbackSlots, name: &String, direction: ConversionDirection, ) -> Result { + use crate::rescript_conversion::Callback; write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); - write_indentation(str, indentation).unwrap(); - write!(str, "let {}ConverterMap = ", name).unwrap(); - - let mut has_instructions = false; - let mut printed_instruction_keys = vec![]; - - instructions.iter().for_each(|instruction_container| { - match &instruction_container.instruction { - ConverterInstructions::ConvertUnion(union_name) => { - if !has_instructions { - has_instructions = true; - writeln!(str, "{{").unwrap(); - } - - if printed_instruction_keys.contains(union_name) { - return; - } else { - printed_instruction_keys.push(union_name.to_string()); - } - - write_indentation(str, indentation + 1).unwrap(); - writeln!( - str, - "\"{}\": {},", - union_name, - format!( - "{}_{}", - match direction { - ConversionDirection::Wrap => "wrap", - ConversionDirection::Unwrap => "unwrap", - }, - union_name, - ), - ) - .unwrap(); - } - ConverterInstructions::ConvertCustomField(custom_field_name, _) => { - if !has_instructions { - has_instructions = true; - writeln!(str, "{{").unwrap(); - } - - if printed_instruction_keys.contains(custom_field_name) { - return; - } else { - printed_instruction_keys.push(custom_field_name.to_string()); - } - - write_indentation(str, indentation + 1).unwrap(); - writeln!( - str, - "\"{}\": {},", - custom_field_name, - match classify_rescript_value_string(&custom_field_name) { - RescriptCustomTypeValue::Type => custom_field_name.to_string(), - RescriptCustomTypeValue::Module => format!( - "{}.{}", - custom_field_name, - match direction { - ConversionDirection::Wrap => "serialize", - ConversionDirection::Unwrap => "parse", - } - ), + write!(str, "let {}Callbacks = ", name).unwrap(); + if callbacks.is_empty() { + writeln!(str, "()").unwrap(); + } else { + writeln!(str, "{{").unwrap(); + for (callback, slot) in callbacks { + let function = match callback { + Callback::Scalar(module) => format!( + "{}.{}", + module, + match direction { + ConversionDirection::Wrap => "serialize", + ConversionDirection::Unwrap => "parse", + } + ), + Callback::Union(name) => format!( + "{}_{}", + match direction { + ConversionDirection::Wrap => "wrap", + ConversionDirection::Unwrap => "unwrap", }, - ) - .unwrap(); - } - _ => (), - }; - }); - - if has_instructions { + name + ), + }; + write_indentation(str, indentation + 1).unwrap(); + writeln!(str, "\"{}\": {},", slot, function).unwrap(); + } write_indentation(str, indentation).unwrap(); writeln!(str, "}}").unwrap(); - } else { - writeln!(str, "()").unwrap() } - Ok(()) } @@ -1275,6 +1124,7 @@ fn write_internal_assets( include_raw: bool, direction: ConversionDirection, nullable_type: NullableType, + shared_plans: &mut std::collections::BTreeMap, ) -> Result { let root_name = root_name_from_context(&target_context); @@ -1284,17 +1134,6 @@ fn write_internal_assets( writeln!(str, "type {}Raw", name).unwrap(); } - write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); - write_indentation(str, indentation).unwrap(); - writeln!( - str, - "let {}Converter: dict>> = %raw(", - name - ) - .unwrap(); - - write_indentation(str, indentation + 1).unwrap(); - // Map out all root objects (ie input objects) used in this conversion // setup. This is because they are recursive, and thus needs to be treated // separately. This only needs to happen when printing variables though, @@ -1324,48 +1163,54 @@ fn write_internal_assets( }) .collect(); - writeln!( - str, - "json`{}`", - get_conversion_instructions( - state, - &target_conversion_instructions, - root_objects.into_iter().collect_vec(), - &root_name + let callbacks = crate::rescript_conversion::callback_slots(&target_conversion_instructions); + let plan = get_conversion_instructions( + state, + &target_conversion_instructions, + root_objects.into_iter().collect_vec(), + &root_name, + &callbacks, + ); + + // Most artifacts need only nullable normalization. Reuse the runtime's + // generic converter instead of allocating a plan and handle per direction. + if plan.is_empty { + write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); + write_indentation(str, indentation).unwrap(); + writeln!( + str, + "let convert{} = value => RescriptRelay.convertWithoutPlan(value, {})", + uppercase_first_letter(name.as_str()), + match nullable_type { + NullableType::Undefined => "None", + NullableType::Null => "null", + }, ) - ) - .unwrap(); + .unwrap(); + return Ok(()); + } write_indentation(str, indentation).unwrap(); - writeln!(str, ")").unwrap(); - - // Converters are either unions (that needs to be wrapped/unwrapped), or - // custom scalars _that are ReScript modules_, and therefore should be - // autoconverted. - let converters: Vec<&InstructionContainer> = target_conversion_instructions - .into_iter() - .filter(|instruction_container| { - match &instruction_container.instruction { - ConverterInstructions::ConvertCustomField(field_name, _) => { - // Try and infer what type of ReScript value this is - match classify_rescript_value_string(&field_name) { - RescriptCustomTypeValue::Type => false, - RescriptCustomTypeValue::Module => true, - } - } - ConverterInstructions::ConvertUnion(_) => true, - _ => false, - } - }) - .collect(); + writeln!(str, "%%private(").unwrap(); + write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); + write_indentation(str, indentation).unwrap(); + let plan = plan.json; + // Read and write directions share immutable metadata, but retain distinct + // callback maps and prepared converters. Share only within this artifact. + if let Some(previous) = shared_plans.get(&plan) { + writeln!(str, "let {}Converter = {}Converter", name, previous).unwrap(); + } else { + writeln!(str, "let {}Converter: JSON.t = %raw(json`{}`)", name, plan).unwrap(); + shared_plans.insert(plan, name.clone()); + } - write_converter_map(str, indentation, &converters, &name, direction).unwrap(); + write_callbacks(str, indentation, &callbacks, &name, direction).unwrap(); write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); write_indentation(str, indentation).unwrap(); writeln!( str, - "let convert{} = v => v->RescriptRelay.convertObj(", + "let prepared{}Converter = RescriptRelay.prepareConversion(", uppercase_first_letter(name.as_str()) ) .unwrap(); @@ -1373,7 +1218,7 @@ fn write_internal_assets( write_indentation(str, indentation + 1).unwrap(); writeln!(str, "{}Converter,", name).unwrap(); write_indentation(str, indentation + 1).unwrap(); - writeln!(str, "{}ConverterMap,", name).unwrap(); + writeln!(str, "{}Callbacks,", name).unwrap(); write_indentation(str, indentation + 1).unwrap(); writeln!( str, @@ -1387,6 +1232,18 @@ fn write_internal_assets( write_indentation(str, indentation).unwrap(); writeln!(str, ")").unwrap(); + write_indentation(str, indentation).unwrap(); + writeln!(str, ")").unwrap(); + + write_suppress_dead_code_warning_annotation(str, indentation).unwrap(); + write_indentation(str, indentation).unwrap(); + writeln!( + str, + "let convert{} = value => RescriptRelay.runConversion(prepared{}Converter, value)", + uppercase_first_letter(name.as_str()), + uppercase_first_letter(name.as_str()) + ) + .unwrap(); Ok(()) } @@ -1848,13 +1705,13 @@ fn write_fragment_definition( if nullable { writeln!( str, - "type fragment = RescriptRelay.CatchResult.t>>" + "type fragment = array>>" ) .unwrap() } else { writeln!( str, - "type fragment = RescriptRelay.CatchResult.t>" + "type fragment = array>" ) .unwrap() } @@ -1886,39 +1743,36 @@ fn write_fragment_definition( .unwrap(); } } - &TopLevelFragmentType::ResultWithUnion(union) => { - if nullable { - write_union_definition( - state, - str, - &context, - indentation, - &union, - Some(String::from("fragment_t")), - &ObjectPrintMode::Standalone, - ) - .unwrap(); - write_indentation(str, indentation).unwrap(); + &TopLevelFragmentType::ResultWithUnion(union) + | &TopLevelFragmentType::ArrayWithResultUnion(union) => { + write_union_definition( + state, + str, + &context, + indentation, + union, + Some(String::from("fragment_t")), + &ObjectPrintMode::Standalone, + ) + .unwrap(); + write_indentation(str, indentation).unwrap(); + let value_type = if nullable { + "option" + } else { + "fragment_t" + }; + if matches!(fragment, TopLevelFragmentType::ArrayWithResultUnion(_)) { writeln!( str, - "type fragment = RescriptRelay.CatchResult.t>" + "type fragment = array>", + value_type ) .unwrap() } else { - write_union_definition( - state, - str, - &context, - indentation, - &union, - Some(String::from("fragment_t")), - &ObjectPrintMode::Standalone, - ) - .unwrap(); - write_indentation(str, indentation).unwrap(); writeln!( str, - "type fragment = RescriptRelay.CatchResult.t" + "type fragment = RescriptRelay.CatchResult.t<{}>", + value_type ) .unwrap() } @@ -2057,8 +1911,7 @@ fn write_get_connection_nodes_function( None => { warn!( "Could not find edges object with type name '{}' for connection '{}'", - edges_obj_type_name, - connection_field_name + edges_obj_type_name, connection_field_name ); } Some(edges_object) => { @@ -2067,28 +1920,28 @@ fn write_get_connection_nodes_function( None => { warn!( "Could not find 'node' field in edges object '{}' for connection '{}'", - edges_obj_type_name, - connection_field_name + edges_obj_type_name, connection_field_name ); } Some(prop_value) => { - let (node_nullable, node_type_name) = - match &prop_value.prop_type.as_ref() { - PropType::RecordReference(node_record_reference) => { - (prop_value.nullable, node_record_reference.to_string()) - } - PropType::UnionReference(node_union_reference) => { - (prop_value.nullable, node_union_reference.to_string()) - } - other_type => { - warn!( - "Unexpected node type in connection '{}': expected RecordReference or UnionReference, got {:?}", - connection_field_name, - other_type - ); - (prop_value.nullable, String::from("invalid_node_type")) - } - }; + let (node_nullable, node_type_name) = match &prop_value + .prop_type + .as_ref() + { + PropType::RecordReference(node_record_reference) => { + (prop_value.nullable, node_record_reference.to_string()) + } + PropType::UnionReference(node_union_reference) => { + (prop_value.nullable, node_union_reference.to_string()) + } + other_type => { + warn!( + "Unexpected node type in connection '{}': expected RecordReference or UnionReference, got {:?}", + connection_field_name, other_type + ); + (prop_value.nullable, String::from("invalid_node_type")) + } + }; // We've got all we need, let's print the function itself writeln!(str, "").unwrap(); @@ -2581,6 +2434,7 @@ impl Writer for ReScriptPrinter { _, TopLevelFragmentType::Union(fragment_union) | TopLevelFragmentType::ResultWithUnion(fragment_union) + | TopLevelFragmentType::ArrayWithResultUnion(fragment_union) | TopLevelFragmentType::ArrayWithUnion(fragment_union), )) => { write_union_converters(&mut generated_types, indentation, &fragment_union).unwrap(); @@ -2628,6 +2482,8 @@ impl Writer for ReScriptPrinter { } } + let mut shared_conversion_plans = std::collections::BTreeMap::new(); + // Print internal module. This module holds a bunch of things needed for // conversions etc, but that we want to keep in its own module. Mostly // just to reiterate that things found in here are indeed internal, and @@ -2648,6 +2504,7 @@ impl Writer for ReScriptPrinter { true, ConversionDirection::Unwrap, NullableType::Undefined, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2674,6 +2531,7 @@ impl Writer for ReScriptPrinter { } else { NullableType::Undefined }, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2703,6 +2561,7 @@ impl Writer for ReScriptPrinter { true, ConversionDirection::Wrap, NullableType::Null, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2720,6 +2579,7 @@ impl Writer for ReScriptPrinter { true, ConversionDirection::Unwrap, NullableType::Undefined, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2747,6 +2607,7 @@ impl Writer for ReScriptPrinter { true, ConversionDirection::Wrap, NullableType::Null, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2764,6 +2625,7 @@ impl Writer for ReScriptPrinter { true, ConversionDirection::Unwrap, NullableType::Undefined, + &mut shared_conversion_plans, ) .unwrap(); } @@ -2970,8 +2832,13 @@ impl Writer for ReScriptPrinter { .iter() .unique_by(|full_enum| &full_enum.name) .for_each(|full_enum| { - write_enum_util_functions(&self, &mut generated_types, indentation, &full_enum) - .unwrap() + write_enum_util_functions( + &self, + &mut generated_types, + indentation, + &full_enum, + ) + .unwrap() }); } } @@ -3183,8 +3050,10 @@ impl Writer for ReScriptPrinter { _ => Context::Response, }; + // Relay reads plural fragments one item at a time, so @catch + // wraps each item, even when typegen's AST wraps the array. let is_result = match cto { - Some((_, ClassifiedTopLevelObjectType::Result(_))) => true, + Some((_, ClassifiedTopLevelObjectType::ArrayWithResult(_))) => true, _ => false, }; @@ -3240,7 +3109,11 @@ impl Writer for ReScriptPrinter { Some((nullable, TopLevelFragmentType::Union(fragment_union_type))); Ok(()) } - Some((nullable, ClassifiedTopLevelObjectType::ResultWithUnion(members_raw))) => { + Some(( + nullable, + ClassifiedTopLevelObjectType::ResultWithUnion(members_raw) + | ClassifiedTopLevelObjectType::ArrayWithResultUnion(members_raw), + )) => { let context = Context::Fragment; let mut current_path = vec![root_name_from_context(&context)]; @@ -3266,7 +3139,14 @@ impl Writer for ReScriptPrinter { self.fragment = Some(( nullable, - TopLevelFragmentType::ResultWithUnion(fragment_union_type), + if matches!( + cto, + Some((_, ClassifiedTopLevelObjectType::ArrayWithResultUnion(_))) + ) { + TopLevelFragmentType::ArrayWithResultUnion(fragment_union_type) + } else { + TopLevelFragmentType::ResultWithUnion(fragment_union_type) + }, )); Ok(()) } @@ -3500,6 +3380,19 @@ impl Writer for ReScriptPrinter { needs_conversion: needs_conversion.clone(), }); + let list_depth = + crate::rescript_conversion::list_depth(return_type_ast); + if needs_conversion.is_some() && list_depth > 0 { + self.conversion_instructions.push(InstructionContainer { + context: Context::Variables, + at_path: vec![ + String::from("variables"), + key_value_pair_key.to_string(), + ], + instruction: ConverterInstructions::ListDepth(list_depth), + }); + } + // Make sure we note any provided // variable that needs runtime // conversion for input objects or @@ -3646,6 +3539,104 @@ mod tests { ) } + fn assert_plural_catch_shape(payload: AST, nullable: bool, is_union: bool) { + let payload = if nullable { + AST::Nullable(Box::new(payload)) + } else { + payload + }; + // Relay typegen can wrap the array; useFragment wraps each item. + let shapes = [ + AST::GenericType { + outer: "Result".intern(), + inner: vec![AST::ReadOnlyArray(Box::new(payload.clone()))], + }, + AST::ReadOnlyArray(Box::new(AST::GenericType { + outer: "Result".intern(), + inner: vec![payload], + })), + ]; + for shape in shapes { + let mut state = Box::new(make_printer(false)); + state + .write_export_type("TestFragment$data", &shape) + .unwrap(); + let (actual_nullable, fragment) = state.fragment.as_ref().unwrap(); + assert_eq!(*actual_nullable, nullable); + match fragment { + TopLevelFragmentType::ArrayWithResult(object) if !is_union => { + assert_eq!(object.at_path, vec!["fragment", "value"]); + } + TopLevelFragmentType::ArrayWithResultUnion(union) if is_union => { + assert_eq!(union.at_path, vec!["fragment", "value"]); + assert!(state.conversion_instructions.iter().any(|instruction| { + instruction.at_path == vec!["fragment", "value"] + && matches!( + instruction.instruction, + ConverterInstructions::ConvertUnion(_) + ) + })); + } + other => panic!("Expected plural results, got {:?}", other), + } + let mut output = String::new(); + write_fragment_definition( + &state, + &mut output, + 0, + fragment, + &Context::Fragment, + nullable, + ) + .unwrap(); + let value_type = if nullable { + "option" + } else { + "fragment_t" + }; + assert!( + output.contains(&format!( + "type fragment = array>", + value_type + )), + "{}", + output + ); + } + } + + #[test] + fn plural_catch_wraps_each_fragment_and_converts_inside_value() { + for nullable in [false, true] { + assert_plural_catch_shape( + AST::ExactObject(crate::writer::ExactObject::new(vec![])), + nullable, + false, + ); + } + } + + #[test] + fn plural_catch_preserves_abstract_payloads_and_nullability() { + let members = ["User", "Group"] + .iter() + .map(|name| { + AST::ExactObject(crate::writer::ExactObject::new(vec![Prop::KeyValuePair( + KeyValuePairProp { + key: "__typename".intern(), + value: AST::StringLiteral(crate::writer::StringLiteral(name.intern())), + read_only: true, + optional: false, + }, + )])) + }) + .collect(); + let union = AST::Union(crate::writer::SortedASTList::new(members)); + for nullable in [false, true] { + assert_plural_catch_shape(union.clone(), nullable, true); + } + } + #[test] fn enum_utils_use_explicit_string_matching_when_future_proofing_is_disabled() { let state = make_printer(true); diff --git a/compiler/crates/relay-typegen/src/rescript_ast.rs b/compiler/crates/relay-typegen/src/rescript_ast.rs index bcff963972470..2faa8312ee935 100644 --- a/compiler/crates/relay-typegen/src/rescript_ast.rs +++ b/compiler/crates/relay-typegen/src/rescript_ast.rs @@ -98,6 +98,7 @@ pub struct FullEnum { // and apply them accordingly. #[derive(Debug, Clone)] pub enum ConverterInstructions { + ListDepth(usize), ConvertUnion(String), ConvertCustomField(String, bool), HasFragments, diff --git a/compiler/crates/relay-typegen/src/rescript_conversion.rs b/compiler/crates/relay-typegen/src/rescript_conversion.rs new file mode 100644 index 0000000000000..4386393504882 --- /dev/null +++ b/compiler/crates/relay-typegen/src/rescript_conversion.rs @@ -0,0 +1,329 @@ +//! Lossless, versioned conversion metadata. Runtime preparation turns these +//! path entries into reusable converters; response traversal never joins paths. +use std::collections::BTreeMap; + +use serde_json::Map; +use serde_json::Value; +use serde_json::json; + +use crate::rescript_ast::ConverterInstructions; +use crate::rescript_ast::InstructionContainer; + +// Provided variables arrive through a separate AST route. Keep every list +// wrapper, including lists of input objects and nullable nested lists. +pub(crate) fn list_depth(ast: &crate::writer::AST) -> usize { + use crate::writer::AST; + match ast { + AST::Nullable(inner) | AST::NonNullable(inner) => list_depth(inner), + AST::ReadOnlyArray(inner) => 1 + list_depth(inner), + _ => 0, + } +} + +// Slots are local to one conversion context. Names remain in the generated +// callback table, but repeated plan entries only need the short slot ID. +#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] +pub(crate) enum Callback { + Scalar(String), + Union(String), +} + +pub(crate) type CallbackSlots = BTreeMap; + +pub(crate) fn callback_slots(instructions: &[&InstructionContainer]) -> CallbackSlots { + instructions + .iter() + .filter_map(|instruction| match &instruction.instruction { + ConverterInstructions::ConvertCustomField(name, _) => { + Some(Callback::Scalar(name.clone())) + } + ConverterInstructions::ConvertUnion(name) => Some(Callback::Union(name.clone())), + _ => None, + }) + .collect::>() + .into_iter() + .enumerate() + .map(|(id, callback)| (callback, id)) + .collect() +} + +pub(crate) struct ConversionPlan { + pub json: String, + pub is_empty: bool, +} + +pub(crate) fn write_plan( + roots: Vec<(String, Vec<&InstructionContainer>)>, + callbacks: &CallbackSlots, +) -> ConversionPlan { + let mut output = BTreeMap::new(); + for (name, instructions) in roots { + let mut entries: BTreeMap, Map> = BTreeMap::new(); + for instruction in instructions { + let entry = entries + .entry(instruction.at_path[1..].to_vec()) + .or_default(); + let (key, value) = match &instruction.instruction { + ConverterInstructions::ListDepth(depth) => ("list", json!(depth)), + ConverterInstructions::ConvertCustomField(name, array) => { + if *array { + entry.entry("list").or_insert(json!(1)); + } + ( + "scalar", + json!(callbacks[&Callback::Scalar(name.clone())].to_string()), + ) + } + ConverterInstructions::BlockTraversal(array) => { + if *array { + entry.entry("list").or_insert(json!(1)); + } + ("opaque", json!(true)) + } + ConverterInstructions::ConvertUnion(name) => ( + "union", + json!(callbacks[&Callback::Union(name.clone())].to_string()), + ), + ConverterInstructions::RootObject(name) => ("reference", json!(name)), + ConverterInstructions::HasFragments => ("fragments", json!(true)), + }; + if key == "list" { + let depth = entry + .get(key) + .and_then(Value::as_u64) + .unwrap_or(0) + .max(value.as_u64().unwrap()); + entry.insert(key.to_string(), json!(depth)); + } else { + entry.insert(key.to_string(), value); + } + } + // Generic nullable traversal already handles lists recursively. Explicit + // depth is needed only at/above scalar, union, reference, opaque or + // fragment operations. Keep those boundaries, omit plain-data hints. + let mut needed_lists = std::collections::BTreeSet::new(); + for (path, entry) in &entries { + if entry.keys().any(|key| key != "list") { + for depth in 0..path.len() { + needed_lists.insert(path[..depth].to_vec()); + } + } + } + entries.retain(|path, entry| { + entry.len() != 1 || !entry.contains_key("list") || needed_lists.contains(path) + }); + let entries = entries + .into_iter() + .map(|(path, mut entry)| { + entry.insert("path".to_string(), json!(path)); + Value::Object(entry) + }) + .collect::>(); + output.insert(name, entries); + } + let is_empty = output.len() == 1 && output.get("__root").is_some_and(Vec::is_empty); + ConversionPlan { + json: json!({"version": 2, "roots": output}).to_string(), + is_empty, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::rescript_ast::Context; + fn at(path: &[&str], instruction: ConverterInstructions) -> InstructionContainer { + InstructionContainer { + context: Context::Response, + at_path: path.iter().map(|s| s.to_string()).collect(), + instruction, + } + } + fn render(roots: Vec<(String, Vec<&InstructionContainer>)>) -> String { + let instructions = roots + .iter() + .flat_map(|(_, entries)| entries.iter().copied()) + .collect::>(); + let slots = callback_slots(&instructions); + write_plan(roots, &slots).json + } + #[test] + fn provided_variable_depth_keeps_nullable_wrappers() { + use crate::writer::AST; + let scalar = AST::Nullable(Box::new(AST::String)); + let inner = AST::NonNullable(Box::new(AST::ReadOnlyArray(Box::new(scalar)))); + let ast = AST::Nullable(Box::new(AST::ReadOnlyArray(Box::new(inner)))); + assert_eq!(list_depth(&ast), 2); + assert_eq!(list_depth(&AST::String), 0); + } + #[test] + fn preserves_path_boundaries_and_nested_list_depth() { + let instructions = [ + at( + &["response", "a_b"], + ConverterInstructions::ConvertCustomField("A".into(), false), + ), + at( + &["response", "a", "b"], + ConverterInstructions::ConvertCustomField("B".into(), false), + ), + at(&["response", "items"], ConverterInstructions::ListDepth(1)), + at(&["response", "items"], ConverterInstructions::ListDepth(2)), + at( + &["response", "items"], + ConverterInstructions::ConvertCustomField("ArrayScalar".into(), true), + ), + ]; + let value: Value = serde_json::from_str(&render(vec![( + "__root".into(), + instructions.iter().collect(), + )])) + .unwrap(); + assert_eq!( + value, + json!({"version":2,"roots":{"__root":[ + {"path":["a","b"],"scalar":"2"}, + {"path":["a_b"],"scalar":"0"}, + {"path":["items"],"list":2,"scalar":"1"} + ]}}) + ); + } + #[test] + fn instruction_order_and_duplicates_do_not_change_plan() { + let mut instructions = vec![ + at( + &["response", "items"], + ConverterInstructions::BlockTraversal(true), + ), + at(&["response", "items"], ConverterInstructions::ListDepth(3)), + at(&["response", "items"], ConverterInstructions::ListDepth(1)), + at( + &["response", "items"], + ConverterInstructions::BlockTraversal(true), + ), + ]; + let first = render(vec![("__root".into(), instructions.iter().collect())]); + instructions.reverse(); + assert_eq!( + first, + render(vec![("__root".into(), instructions.iter().collect())]) + ); + let value: Value = serde_json::from_str(&first).unwrap(); + assert_eq!(value["roots"]["__root"][0]["list"], 3); + } + #[test] + fn callback_slots_are_stable_deduplicated_and_kind_specific() { + let mut instructions = vec![ + at( + &["response", "a"], + ConverterInstructions::ConvertUnion("Same".into()), + ), + at( + &["response", "b"], + ConverterInstructions::ConvertCustomField("Same".into(), false), + ), + at( + &["response", "c"], + ConverterInstructions::ConvertCustomField("Same".into(), true), + ), + ]; + for i in 0..12 { + instructions.push(at( + &["Input", &format!("f{i}")], + ConverterInstructions::ConvertCustomField(format!("Scalar{i}"), false), + )); + } + let refs = instructions.iter().collect::>(); + let slots = callback_slots(&refs); + assert_eq!(slots.len(), 14); + assert_ne!( + slots[&Callback::Scalar("Same".into())], + slots[&Callback::Union("Same".into())] + ); + let output: Value = + serde_json::from_str(&write_plan(vec![("__root".into(), refs)], &slots).json).unwrap(); + let entries = output["roots"]["__root"].as_array().unwrap(); + for instruction in &instructions { + let (key, callback) = match &instruction.instruction { + ConverterInstructions::ConvertCustomField(name, _) => { + ("scalar", Callback::Scalar(name.clone())) + } + ConverterInstructions::ConvertUnion(name) => { + ("union", Callback::Union(name.clone())) + } + _ => unreachable!(), + }; + let path = json!(instruction.at_path[1..]); + let entry = entries.iter().find(|entry| entry["path"] == path).unwrap(); + assert_eq!(entry[key], json!(slots[&callback].to_string())); + } + instructions.reverse(); + assert_eq!( + slots, + callback_slots(&instructions.iter().collect::>()) + ); + } + #[test] + fn plain_list_hints_collapse_to_the_shared_converter() { + let instructions = [ + at(&["response"], ConverterInstructions::ListDepth(2)), + at(&["response", "items"], ConverterInstructions::ListDepth(1)), + at( + &["response", "items", "values"], + ConverterInstructions::ListDepth(3), + ), + ]; + let plan = write_plan( + vec![("__root".into(), instructions.iter().collect())], + &CallbackSlots::new(), + ); + assert!(plan.is_empty); + assert_eq!( + serde_json::from_str::(&plan.json).unwrap(), + json!({"version":2,"roots":{"__root":[]}}) + ); + } + + #[test] + fn list_hints_keep_every_required_operation_boundary() { + let operations = [ + ConverterInstructions::ConvertCustomField("Scalar".into(), true), + ConverterInstructions::ConvertUnion("Union".into()), + ConverterInstructions::RootObject("Input".into()), + ConverterInstructions::BlockTraversal(true), + ConverterInstructions::HasFragments, + ]; + for operation in operations { + let instructions = [ + at(&["response", "items"], ConverterInstructions::ListDepth(2)), + at( + &["response", "items", "child"], + ConverterInstructions::ListDepth(3), + ), + at(&["response", "items", "child"], operation), + at( + &["response", "items_child"], + ConverterInstructions::ListDepth(1), + ), + at(&["response", "unused"], ConverterInstructions::ListDepth(1)), + at( + &["response", "unused", "values"], + ConverterInstructions::ListDepth(2), + ), + ]; + let refs = instructions.iter().collect::>(); + let slots = callback_slots(&refs); + let plan = write_plan( + vec![("__root".into(), refs), ("Input".into(), vec![])], + &slots, + ); + assert!(!plan.is_empty); + let value: Value = serde_json::from_str(&plan.json).unwrap(); + let entries = value["roots"]["__root"].as_array().unwrap(); + assert_eq!(entries.len(), 2); + assert_eq!(entries[0], json!({"path":["items"],"list":2})); + assert_eq!(entries[1]["path"], json!(["items", "child"])); + assert_eq!(entries[1]["list"], 3); + } + } +} diff --git a/compiler/crates/relay-typegen/src/rescript_utils.rs b/compiler/crates/relay-typegen/src/rescript_utils.rs index 5b189e551e73a..1753b1bd88131 100644 --- a/compiler/crates/relay-typegen/src/rescript_utils.rs +++ b/compiler/crates/relay-typegen/src/rescript_utils.rs @@ -133,6 +133,7 @@ pub enum ClassifiedTopLevelObjectType<'a> { ArrayWithObject(&'a Vec), ArrayWithUnion(&'a Vec), ArrayWithResult(&'a Vec), + ArrayWithResultUnion(&'a Vec), } // This classifies top level object types, meaning anything that comes in the @@ -170,25 +171,40 @@ pub fn classify_top_level_object_type_ast( array_item_nullable, ClassifiedTopLevelObjectType::ArrayWithResult(&ast), )), + Some((item_nullable, ClassifiedTopLevelObjectType::ResultWithUnion(members))) => { + Some(( + item_nullable, + ClassifiedTopLevelObjectType::ArrayWithResultUnion(members), + )) + } _ => None, } } &AST::GenericType { outer, inner } => { if outer.eq(&"Result".intern()) { - let ok_ast = inner.get(0).unwrap(); - match &ok_ast { - &AST::ExactObject(props) => { - Some((nullable, ClassifiedTopLevelObjectType::Result(&props))) - } - &AST::Union(members) => Some(( - nullable, - ClassifiedTopLevelObjectType::ResultWithUnion(&members), + let (payload_nullable, ok_ast) = unwrap_ast(inner.first()?); + match ok_ast { + AST::ExactObject(props) => Some(( + nullable || payload_nullable, + ClassifiedTopLevelObjectType::Result(props), + )), + AST::Union(members) => Some(( + nullable || payload_nullable, + ClassifiedTopLevelObjectType::ResultWithUnion(members), )), - &AST::ReadOnlyArray(inner_ast) => match &inner_ast.as_ref() { - &AST::ExactObject(props) => Some(( - nullable, - ClassifiedTopLevelObjectType::ArrayWithResult(&props), - )), + AST::ReadOnlyArray(item) => match classify_top_level_object_type_ast(item) { + Some((item_nullable, ClassifiedTopLevelObjectType::Object(props))) => { + Some(( + item_nullable, + ClassifiedTopLevelObjectType::ArrayWithResult(props), + )) + } + Some((item_nullable, ClassifiedTopLevelObjectType::Union(members))) => { + Some(( + item_nullable, + ClassifiedTopLevelObjectType::ArrayWithResultUnion(members), + )) + } _ => None, }, _ => None, @@ -357,6 +373,7 @@ pub fn get_safe_key(original_key: &String) -> (String, Option) { pub fn instruction_to_key_value_pair(instruction: &ConverterInstructions) -> (String, String) { match &instruction { + &ConverterInstructions::ListDepth(depth) => (String::from("list"), depth.to_string()), &ConverterInstructions::ConvertUnion(union_record_name) => { (String::from("u"), union_record_name.to_string()) } diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_graphql.res index 0a150c20e535a..5f3fdf1e63805 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_graphql.res @@ -35,49 +35,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"response_member"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["member"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_member": wrap_response_member, + let wrapResponseCallbacks = { + "0": wrap_response_member, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"response_member"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_member": unwrap_response_member, + let responseCallbacks = { + "0": unwrap_response_member, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_preloadable_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_preloadable_graphql.res index 7676127646733..51026b0dcdc64 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_preloadable_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithCodesplitQuery_preloadable_graphql.res @@ -11,17 +11,7 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_graphql.res index 270baabf17b28..9e72b44b48582 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_graphql.res @@ -35,12 +35,12 @@ module Types = { } @live type refetchVariables = { - status: option>, + status?: option, } @live let makeRefetchVariables = ( ~status=?, ): refetchVariables => { - status: status + status: ?status } } @@ -49,48 +49,54 @@ module Types = { type queryRef module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"someInput":{"recursive":{"r":"someInput"},"datetime":{"c":"SomeModule.Datetime"}},"inputA":{"usingB":{"r":"inputB"},"timestamps":{"b":"a"},"timestamp":{"b":""},"time":{"c":"SomeModule.Datetime"},"recursiveA":{"r":"inputA"}},"inputB":{"usingA":{"r":"inputA"},"time":{"c":"SomeModule.Datetime"}},"__root":{"__relay_internal__pv__TestProvidedVariablesSomeInput":{"r":"someInput"},"__relay_internal__pv__TestProvidedVariablesInputB":{"r":"inputB"},"__relay_internal__pv__TestProvidedVariablesDatetimes":{"ca":"SomeModule.Datetime"},"__relay_internal__pv__TestProvidedVariablesDatetime":{"c":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["__relay_internal__pv__TestProvidedVariablesDatetime"],"scalar":"0"},{"list":1,"path":["__relay_internal__pv__TestProvidedVariablesDatetimes"],"scalar":"0"},{"path":["__relay_internal__pv__TestProvidedVariablesInputB"],"reference":"inputB"},{"path":["__relay_internal__pv__TestProvidedVariablesSomeInput"],"reference":"someInput"}],"inputA":[{"path":["recursiveA"],"reference":"inputA"},{"path":["time"],"scalar":"0"},{"opaque":true,"path":["timestamp"]},{"list":1,"opaque":true,"path":["timestamps"]},{"path":["usingB"],"reference":"inputB"}],"inputB":[{"path":["time"],"scalar":"0"},{"path":["usingA"],"reference":"inputA"}],"someInput":[{"path":["datetime"],"scalar":"0"},{"path":["recursive"],"reference":"someInput"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) + ) + @live + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_preloadable_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_preloadable_graphql.res index 6ef6ab78d0841..a89cfb8105d60 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_preloadable_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQueryWithProvidedVariablesQuery_preloadable_graphql.res @@ -15,20 +15,22 @@ module Types = { } module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"someInput":{"recursive":{"r":"someInput"},"datetime":{"c":"SomeModule.Datetime"}},"inputA":{"usingB":{"r":"inputB"},"timestamps":{"b":"a"},"timestamp":{"b":""},"time":{"c":"SomeModule.Datetime"},"recursiveA":{"r":"inputA"}},"inputB":{"usingA":{"r":"inputA"},"time":{"c":"SomeModule.Datetime"}},"__root":{"__relay_internal__pv__TestProvidedVariablesSomeInput":{"r":"someInput"},"__relay_internal__pv__TestProvidedVariablesInputB":{"r":"inputB"},"__relay_internal__pv__TestProvidedVariablesDatetimes":{"ca":"SomeModule.Datetime"},"__relay_internal__pv__TestProvidedVariablesDatetime":{"c":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["__relay_internal__pv__TestProvidedVariablesDatetime"],"scalar":"0"},{"list":1,"path":["__relay_internal__pv__TestProvidedVariablesDatetimes"],"scalar":"0"},{"path":["__relay_internal__pv__TestProvidedVariablesInputB"],"reference":"inputB"},{"path":["__relay_internal__pv__TestProvidedVariablesSomeInput"],"reference":"someInput"}],"inputA":[{"path":["recursiveA"],"reference":"inputA"},{"path":["time"],"scalar":"0"},{"opaque":true,"path":["timestamp"]},{"list":1,"opaque":true,"path":["timestamps"]},{"path":["usingB"],"reference":"inputB"}],"inputB":[{"path":["time"],"scalar":"0"},{"path":["usingA"],"reference":"inputA"}],"someInput":[{"path":["datetime"],"scalar":"0"},{"path":["recursive"],"reference":"someInput"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) + ) + @live + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_graphql.res index 601da21b5f42f..e792d44957e54 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_graphql.res @@ -28,12 +28,12 @@ module Types = { } @live type refetchVariables = { - status: option>, + status?: option, } @live let makeRefetchVariables = ( ~status=?, ): refetchVariables => { - status: status + status: ?status } } @@ -43,45 +43,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_preloadable_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_preloadable_graphql.res index 29ddce4ea06f7..d11482e79027b 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_preloadable_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_preloadable_graphql.res @@ -13,17 +13,7 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_user_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_user_graphql.res index 39b63e8a42c18..49e60894ae9ac 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_user_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/TestPreloadedQuery_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res-preloadable/src/__generated__/UserAvatar_user_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/UserAvatar_user_graphql.res index e8a9be0d576cd..f3ce1402c9ffc 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/UserAvatar_user_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/UserAvatar_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res-preloadable/src/__generated__/UserName_user_graphql.res b/compiler/test-project-res-preloadable/src/__generated__/UserName_user_graphql.res index 760a1274bc6c7..6780204dacd4c 100644 --- a/compiler/test-project-res-preloadable/src/__generated__/UserName_user_graphql.res +++ b/compiler/test-project-res-preloadable/src/__generated__/UserName_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/FriendComponent2_user_graphql.res b/compiler/test-project-res/src/__generated__/FriendComponent2_user_graphql.res index 9842df05e186b..3711c686d0efc 100644 --- a/compiler/test-project-res/src/__generated__/FriendComponent2_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/FriendComponent2_user_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/FriendComponentSkip_user_graphql.res b/compiler/test-project-res/src/__generated__/FriendComponentSkip_user_graphql.res index 040f8cb9cd2e6..04e103336d816 100644 --- a/compiler/test-project-res/src/__generated__/FriendComponentSkip_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/FriendComponentSkip_user_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/FriendComponent_user_graphql.res b/compiler/test-project-res/src/__generated__/FriendComponent_user_graphql.res index c3de8bb1d0e48..f4d345eb4657a 100644 --- a/compiler/test-project-res/src/__generated__/FriendComponent_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/FriendComponent_user_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/GroupAvatar_group_graphql.res b/compiler/test-project-res/src/__generated__/GroupAvatar_group_graphql.res index 72663d7eeebb8..b874158648112 100644 --- a/compiler/test-project-res/src/__generated__/GroupAvatar_group_graphql.res +++ b/compiler/test-project-res/src/__generated__/GroupAvatar_group_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/LocalUser____relay_model_instance_graphql.res b/compiler/test-project-res/src/__generated__/LocalUser____relay_model_instance_graphql.res index a8b2835ff40af..4e3b86052a892 100644 --- a/compiler/test-project-res/src/__generated__/LocalUser____relay_model_instance_graphql.res +++ b/compiler/test-project-res/src/__generated__/LocalUser____relay_model_instance_graphql.res @@ -11,17 +11,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/LocalUser__id_graphql.res b/compiler/test-project-res/src/__generated__/LocalUser__id_graphql.res index ae6aebe9f84ca..f4644bfb293cd 100644 --- a/compiler/test-project-res/src/__generated__/LocalUser__id_graphql.res +++ b/compiler/test-project-res/src/__generated__/LocalUser__id_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/RichContent_content_graphql.res b/compiler/test-project-res/src/__generated__/RichContent_content_graphql.res index 068297c91d017..7f4ab89a3984b 100644 --- a/compiler/test-project-res/src/__generated__/RichContent_content_graphql.res +++ b/compiler/test-project-res/src/__generated__/RichContent_content_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestAliasedFragments_container_graphql.res b/compiler/test-project-res/src/__generated__/TestAliasedFragments_container_graphql.res index 8b5e7f7fc3cf0..57878d5d621e3 100644 --- a/compiler/test-project-res/src/__generated__/TestAliasedFragments_container_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestAliasedFragments_container_graphql.res @@ -15,17 +15,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestAliasedFragments_one_graphql.res b/compiler/test-project-res/src/__generated__/TestAliasedFragments_one_graphql.res index 14509764eebd9..585a58445ddb4 100644 --- a/compiler/test-project-res/src/__generated__/TestAliasedFragments_one_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestAliasedFragments_one_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestAliasedFragments_required_graphql.res b/compiler/test-project-res/src/__generated__/TestAliasedFragments_required_graphql.res index 64130e7916c61..2b909179c3962 100644 --- a/compiler/test-project-res/src/__generated__/TestAliasedFragments_required_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestAliasedFragments_required_graphql.res @@ -18,17 +18,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestAliasedFragments_two_graphql.res b/compiler/test-project-res/src/__generated__/TestAliasedFragments_two_graphql.res index ca89dfa0b472d..9a8772a931077 100644 --- a/compiler/test-project-res/src/__generated__/TestAliasedFragments_two_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestAliasedFragments_two_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriends2Query_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriends2Query_graphql.res index f97f57bedf56a..84b52141e9aa1 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriends2Query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriends2Query_graphql.res @@ -46,53 +46,47 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"member_value_User_memberOfSingular_value_User_createdAt":{"c":"SomeModule.Datetime"},"member_value_User_memberOfSingular_value":{"u":"response_member_value_User_memberOfSingular_value"},"member_value":{"u":"response_member_value"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["member","value"],"union":"1"},{"path":["member","value","User","memberOfSingular","value"],"union":"2"},{"path":["member","value","User","memberOfSingular","value","User","createdAt"],"scalar":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, - "response_member_value_User_memberOfSingular_value": wrap_response_member_value_User_memberOfSingular_value, - "response_member_value": wrap_response_member_value, + let wrapResponseCallbacks = { + "0": SomeModule.Datetime.serialize, + "1": wrap_response_member_value, + "2": wrap_response_member_value_User_memberOfSingular_value, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"member_value_User_memberOfSingular_value_User_createdAt":{"c":"SomeModule.Datetime"},"member_value_User_memberOfSingular_value":{"u":"response_member_value_User_memberOfSingular_value"},"member_value":{"u":"response_member_value"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.parse, - "response_member_value_User_memberOfSingular_value": unwrap_response_member_value_User_memberOfSingular_value, - "response_member_value": unwrap_response_member_value, + let responseCallbacks = { + "0": SomeModule.Datetime.parse, + "1": unwrap_response_member_value, + "2": unwrap_response_member_value_User_memberOfSingular_value, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriends3Query_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriends3Query_graphql.res index c71e9a90fd70d..43dc745afa043 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriends3Query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriends3Query_graphql.res @@ -39,49 +39,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"members_edges_node_value":{"u":"response_members_edges_node_value"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["members","edges"]},{"path":["members","edges","node","value"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_members_edges_node_value": wrap_response_members_edges_node_value, + let wrapResponseCallbacks = { + "0": wrap_response_members_edges_node_value, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"members_edges_node_value":{"u":"response_members_edges_node_value"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_members_edges_node_value": unwrap_response_members_edges_node_value, + let responseCallbacks = { + "0": unwrap_response_members_edges_node_value, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsMutation_graphql.res index d2bf3a8b90812..efedb72f7c0e4 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsMutation_graphql.res @@ -25,45 +25,15 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsQuery_graphql.res index 77e4e5691a044..ba7e170a25f0a 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsQuery_graphql.res @@ -25,45 +25,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUserPlural_user_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUserPlural_user_graphql.res index f9c178b34b20c..3a59e55b69624 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUserPlural_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUserPlural_user_graphql.res @@ -7,26 +7,28 @@ module Types = { type fragment_t = { createdAt: SomeModule.Datetime.t, } - type fragment = array + type fragment = array> } module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"createdAt":{"c":"SomeModule.Datetime"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["value","createdAt"],"scalar":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.parse, + let fragmentCallbacks = { + "0": SomeModule.Datetime.parse, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_member_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_member_graphql.res index b5c8cd29f3ed2..572961a6b1643 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_member_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_member_graphql.res @@ -27,20 +27,22 @@ let wrap_fragment_t: Types.fragment_t => Types.fragment_t = RescriptRelay_Intern module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"value":{"u":"fragment_t"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["value"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_t": unwrap_fragment_t, + let fragmentCallbacks = { + "0": unwrap_fragment_t, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_user_graphql.res b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_user_graphql.res index e5f3f7a61e339..6e25ccaf02a3e 100644 --- a/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCatchAndFriendsUser_user_graphql.res @@ -13,20 +13,22 @@ module Types = { module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"value_createdAt":{"c":"SomeModule.Datetime"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["value","createdAt"],"scalar":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.parse, + let fragmentCallbacks = { + "0": SomeModule.Datetime.parse, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestCodesplitQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestCodesplitQuery_graphql.res index 7d1839e1bef77..458a076ed56c7 100644 --- a/compiler/test-project-res/src/__generated__/TestCodesplitQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCodesplitQuery_graphql.res @@ -46,45 +46,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsPlural_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsPlural_user_graphql.res index 547a52da6f6e5..496abcd943c79 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsPlural_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsPlural_user_graphql.res @@ -23,17 +23,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsUnionPlural_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsUnionPlural_user_graphql.res index 63470f9dab608..14a4a98cdc32b 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsUnionPlural_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsUnionPlural_user_graphql.res @@ -34,20 +34,22 @@ let wrap_fragment_member: Types.fragment_member => Types.fragment_member = Rescr module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"fragment_member"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["member"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_member": unwrap_fragment_member, + let fragmentCallbacks = { + "0": unwrap_fragment_member, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsUnion_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsUnion_user_graphql.res index c5215c76b7a73..2f5f940edb831 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsUnion_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsUnion_user_graphql.res @@ -33,20 +33,22 @@ let wrap_fragment_member: Types.fragment_member => Types.fragment_member = Rescr module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"fragment_member"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["member"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_member": unwrap_fragment_member, + let fragmentCallbacks = { + "0": unwrap_fragment_member, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsWithConstantValues_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsWithConstantValues_user_graphql.res index 6584a50ba81ab..b52a512e63668 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsWithConstantValues_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsWithConstantValues_user_graphql.res @@ -22,17 +22,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsWithEmptyFilters_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsWithEmptyFilters_user_graphql.res index 02f3f3d5aba50..0af63f7e0cf58 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsWithEmptyFilters_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsWithEmptyFilters_user_graphql.res @@ -22,17 +22,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnectionsWithFilters_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnectionsWithFilters_user_graphql.res index 38db66d708d72..9aa84d3283f5c 100644 --- a/compiler/test-project-res/src/__generated__/TestConnectionsWithFilters_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnectionsWithFilters_user_graphql.res @@ -22,17 +22,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestConnections_user_graphql.res b/compiler/test-project-res/src/__generated__/TestConnections_user_graphql.res index 5a47e5a3c1039..d29908d9a30fa 100644 --- a/compiler/test-project-res/src/__generated__/TestConnections_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestConnections_user_graphql.res @@ -22,17 +22,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestCustomScalars2Query_graphql.res b/compiler/test-project-res/src/__generated__/TestCustomScalars2Query_graphql.res index c0d53f9fae78f..75a2c17681268 100644 --- a/compiler/test-project-res/src/__generated__/TestCustomScalars2Query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCustomScalars2Query_graphql.res @@ -29,48 +29,30 @@ module Types = { type queryRef module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"__root":{"asArray":{"ca":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["asArray"],"scalar":"0"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestCustomScalarsQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestCustomScalarsQuery_graphql.res index b33faa5391c96..13be9a110b4d3 100644 --- a/compiler/test-project-res/src/__generated__/TestCustomScalarsQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestCustomScalarsQuery_graphql.res @@ -59,54 +59,60 @@ let wrap_response_member: Types.response_member => Types.response_member = Rescr type queryRef module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"__root":{"datetimes":{"ca":"SomeModule.Datetime"},"beforeDate":{"c":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["beforeDate"],"scalar":"0"},{"list":1,"path":["datetimes"],"scalar":"0"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) + ) + @live + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"member_User_datetimes":{"ca":"SomeModule.Datetime"},"member_User_createdAt":{"c":"SomeModule.Datetime"},"member":{"u":"response_member"},"loggedInUser_friends_createdAt":{"c":"SomeModule.Datetime"},"loggedInUser_datetimes":{"ca":"SomeModule.Datetime"},"loggedInUser_createdAt":{"c":"SomeModule.Datetime"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["loggedInUser","createdAt"],"scalar":"0"},{"list":1,"path":["loggedInUser","datetimes"],"scalar":"0"},{"list":1,"path":["loggedInUser","friends"]},{"path":["loggedInUser","friends","createdAt"],"scalar":"0"},{"path":["member"],"union":"1"},{"path":["member","User","createdAt"],"scalar":"0"},{"list":1,"path":["member","User","datetimes"],"scalar":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, - "response_member": wrap_response_member, + let wrapResponseCallbacks = { + "0": SomeModule.Datetime.serialize, + "1": wrap_response_member, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"member_User_datetimes":{"ca":"SomeModule.Datetime"},"member_User_createdAt":{"c":"SomeModule.Datetime"},"member":{"u":"response_member"},"loggedInUser_friends_createdAt":{"c":"SomeModule.Datetime"},"loggedInUser_datetimes":{"ca":"SomeModule.Datetime"},"loggedInUser_createdAt":{"c":"SomeModule.Datetime"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.parse, - "response_member": unwrap_response_member, + let responseCallbacks = { + "0": SomeModule.Datetime.parse, + "1": unwrap_response_member, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestFragmentQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestFragmentQuery_graphql.res index c7ab07194e89c..15566b55e7e62 100644 --- a/compiler/test-project-res/src/__generated__/TestFragmentQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragmentQuery_graphql.res @@ -36,45 +36,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"users_edges_node":{"f":""},"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]},{"list":1,"path":["users","edges"]},{"fragments":true,"path":["users","edges","node"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"users_edges_node":{"f":""},"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestFragment_allowUnsafeEnum_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_allowUnsafeEnum_graphql.res index 5bfd886b22e68..eb3e8208ebe0f 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_allowUnsafeEnum_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_allowUnsafeEnum_graphql.res @@ -15,17 +15,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_ignoreUnused_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_ignoreUnused_graphql.res index 06d8d3b07d447..beb8c112bc65e 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_ignoreUnused_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_ignoreUnused_graphql.res @@ -15,17 +15,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_inline_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_inline_graphql.res index 80740d2b5c9ed..440a4dc1334dc 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_inline_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_inline_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_plural_user_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_plural_user_graphql.res index 7d1e1c22d2273..5d399f3eaf8d9 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_plural_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_plural_user_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_requiredPlural_user_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_requiredPlural_user_graphql.res index 60201ecfffa1c..6c7f6aa5e9725 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_requiredPlural_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_requiredPlural_user_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_requiredUnionPlural_member_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_requiredUnionPlural_member_graphql.res index c223169211c58..0b9cd26551706 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_requiredUnionPlural_member_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_requiredUnionPlural_member_graphql.res @@ -29,20 +29,22 @@ let wrap_fragment: Types.fragment => Types.fragment = RescriptRelay_Internal.wra module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"":{"u":"fragment"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":[],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment": unwrap_fragment, + let fragmentCallbacks = { + "0": unwrap_fragment, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_requiredUnion_member_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_requiredUnion_member_graphql.res index 87fd5c6311524..fae482185868e 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_requiredUnion_member_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_requiredUnion_member_graphql.res @@ -29,20 +29,22 @@ let wrap_fragment: Types.fragment => Types.fragment = RescriptRelay_Internal.wra module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"":{"u":"fragment"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":[],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment": unwrap_fragment, + let fragmentCallbacks = { + "0": unwrap_fragment, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_required_user_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_required_user_graphql.res index 53cffd7abbc8c..d6b6ef41cdfa7 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_required_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_required_user_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_sub_user_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_sub_user_graphql.res index 8c56349b9f886..95bedfd1dbf43 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_sub_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_sub_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestFragment_user_graphql.res b/compiler/test-project-res/src/__generated__/TestFragment_user_graphql.res index d64f871c89c01..a150a804d3328 100644 --- a/compiler/test-project-res/src/__generated__/TestFragment_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestFragment_user_graphql.res @@ -15,18 +15,20 @@ module Types = { module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":[]}]},"version":2}`) @live - let fragmentConverterMap = () + let fragmentCallbacks = () @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestInterfaces_hasName_graphql.res b/compiler/test-project-res/src/__generated__/TestInterfaces_hasName_graphql.res index e2ab531a52b1f..54da69000db31 100644 --- a/compiler/test-project-res/src/__generated__/TestInterfaces_hasName_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestInterfaces_hasName_graphql.res @@ -31,20 +31,22 @@ let wrap_fragment_byType: Types.fragment_byType => Types.fragment_byType = Rescr module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"byType":{"u":"fragment_byType"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["byType"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_byType": unwrap_fragment_byType, + let fragmentCallbacks = { + "0": unwrap_fragment_byType, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestLocalPayloadQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestLocalPayloadQuery_graphql.res index 5a62190e73101..85739f093ed6a 100644 --- a/compiler/test-project-res/src/__generated__/TestLocalPayloadQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestLocalPayloadQuery_graphql.res @@ -33,73 +33,47 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) - @live - type wrapRawResponseRaw - @live - let wrapRawResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapRawResponseConverterMap = () + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( - wrapRawResponseConverter, - wrapRawResponseConverterMap, - null - ) - @live - type rawResponseRaw + type wrapRawResponseRaw @live - let rawResponseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapRawResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let rawResponseConverterMap = () + type rawResponseRaw @live - let convertRawResponse = v => v->RescriptRelay.convertObj( - rawResponseConverter, - rawResponseConverterMap, - None - ) + let convertRawResponse = value => RescriptRelay.convertWithoutPlan(value, None) type rawPreloadToken<'response> = {source: Nullable.t>} external tokenToRaw: queryRef => rawPreloadToken = "%identity" } diff --git a/compiler/test-project-res/src/__generated__/TestLocalPayloadViaNodeInterfaceQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestLocalPayloadViaNodeInterfaceQuery_graphql.res index e87966a904301..bcf4b53913cfc 100644 --- a/compiler/test-project-res/src/__generated__/TestLocalPayloadViaNodeInterfaceQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestLocalPayloadViaNodeInterfaceQuery_graphql.res @@ -61,81 +61,79 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["node"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_node": wrap_response_node, + let wrapResponseCallbacks = { + "0": wrap_response_node, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_node": unwrap_response_node, + let responseCallbacks = { + "0": unwrap_response_node, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) @live type wrapRawResponseRaw + %%private( @live - let wrapRawResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"rawResponse_node"}}}` - ) + let wrapRawResponseConverter = wrapResponseConverter @live - let wrapRawResponseConverterMap = { - "rawResponse_node": wrap_rawResponse_node, + let wrapRawResponseCallbacks = { + "0": wrap_rawResponse_node, } @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( + let preparedWrapRawResponseConverter = RescriptRelay.prepareConversion( wrapRawResponseConverter, - wrapRawResponseConverterMap, + wrapRawResponseCallbacks, null ) + ) + @live + let convertWrapRawResponse = value => RescriptRelay.runConversion(preparedWrapRawResponseConverter, value) @live type rawResponseRaw + %%private( @live - let rawResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"rawResponse_node"}}}` - ) + let rawResponseConverter = wrapResponseConverter @live - let rawResponseConverterMap = { - "rawResponse_node": unwrap_rawResponse_node, + let rawResponseCallbacks = { + "0": unwrap_rawResponse_node, } @live - let convertRawResponse = v => v->RescriptRelay.convertObj( + let preparedRawResponseConverter = RescriptRelay.prepareConversion( rawResponseConverter, - rawResponseConverterMap, + rawResponseCallbacks, None ) + ) + @live + let convertRawResponse = value => RescriptRelay.runConversion(preparedRawResponseConverter, value) type rawPreloadToken<'response> = {source: Nullable.t>} external tokenToRaw: queryRef => rawPreloadToken = "%identity" } diff --git a/compiler/test-project-res/src/__generated__/TestLocalPayload_user_graphql.res b/compiler/test-project-res/src/__generated__/TestLocalPayload_user_graphql.res index 0ce1aebfed23b..d59c3075664e7 100644 --- a/compiler/test-project-res/src/__generated__/TestLocalPayload_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestLocalPayload_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersMeQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersMeQuery_graphql.res index 3ab9c8c2ddc96..aa0da3d499f2e 100644 --- a/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersMeQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersMeQuery_graphql.res @@ -24,45 +24,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersQuery_graphql.res index acaea7b38ce4a..e98590678ceff 100644 --- a/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMissingFieldHandlersQuery_graphql.res @@ -33,49 +33,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["node"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_node": wrap_response_node, + let wrapResponseCallbacks = { + "0": wrap_response_node, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_node": unwrap_response_node, + let responseCallbacks = { + "0": unwrap_response_node, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestModelResolverAliasedQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestModelResolverAliasedQuery_graphql.res index a7c7dd2d8cff8..9e7374581dc7e 100644 --- a/compiler/test-project-res/src/__generated__/TestModelResolverAliasedQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestModelResolverAliasedQuery_graphql.res @@ -28,45 +28,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestModelResolverInlineQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestModelResolverInlineQuery_graphql.res index 77a973e06756d..d5bef0c3ca564 100644 --- a/compiler/test-project-res/src/__generated__/TestModelResolverInlineQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestModelResolverInlineQuery_graphql.res @@ -28,45 +28,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutationInline_user_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationInline_user_graphql.res index 08abfc24937dd..f1b8f229e2877 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationInline_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationInline_user_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestMutationNullabilityMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationNullabilityMutation_graphql.res index 349da4a70c1e9..e1f7014f04403 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationNullabilityMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationNullabilityMutation_graphql.res @@ -32,48 +32,30 @@ module Types = { } module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"someInput":{"recursive":{"r":"someInput"},"datetime":{"c":"SomeModule.Datetime"}},"__root":{"recursive":{"r":"someInput"},"datetime":{"c":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["datetime"],"scalar":"0"},{"path":["recursive"],"reference":"someInput"}],"someInput":[{"path":["datetime"],"scalar":"0"},{"path":["recursive"],"reference":"someInput"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, null ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutationQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationQuery_graphql.res index 140c9bc90f6df..40bfc68be3474 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationQuery_graphql.res @@ -24,45 +24,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusComplexMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusComplexMutation_graphql.res index d763c68ff07b6..a53be6e590c95 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusComplexMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusComplexMutation_graphql.res @@ -28,46 +28,28 @@ module Types = { } module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"recursiveSetOnlineStatusInput":{"setOnlineStatus":{"r":"setOnlineStatusInput"}},"setOnlineStatusInput":{"recursed":{"r":"recursiveSetOnlineStatusInput"}},"__root":{"input":{"r":"setOnlineStatusInput"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["input"],"reference":"setOnlineStatusInput"}],"recursiveSetOnlineStatusInput":[{"path":["setOnlineStatus"],"reference":"setOnlineStatusInput"}],"setOnlineStatusInput":[{"path":["recursed"],"reference":"recursiveSetOnlineStatusInput"}]},"version":2}`) @live - let variablesConverterMap = () + let variablesCallbacks = () @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusMutation_graphql.res index e1fc5585baf33..0baed99c53e85 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationSetOnlineStatusMutation_graphql.res @@ -43,73 +43,47 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["setOnlineStatus","user"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) - @live - type wrapRawResponseRaw - @live - let wrapRawResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapRawResponseConverterMap = () + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( - wrapRawResponseConverter, - wrapRawResponseConverterMap, - null - ) - @live - type rawResponseRaw + type wrapRawResponseRaw @live - let rawResponseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapRawResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let rawResponseConverterMap = () + type rawResponseRaw @live - let convertRawResponse = v => v->RescriptRelay.convertObj( - rawResponseConverter, - rawResponseConverterMap, - None - ) + let convertRawResponse = value => RescriptRelay.convertWithoutPlan(value, None) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res/src/__generated__/TestMutationWithInlineFragmentSetOnlineStatusMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationWithInlineFragmentSetOnlineStatusMutation_graphql.res index 63e5438e7b1fd..19df643f2de6d 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationWithInlineFragmentSetOnlineStatusMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationWithInlineFragmentSetOnlineStatusMutation_graphql.res @@ -39,73 +39,47 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["setOnlineStatus","user"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) - @live - type wrapRawResponseRaw - @live - let wrapRawResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapRawResponseConverterMap = () + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( - wrapRawResponseConverter, - wrapRawResponseConverterMap, - null - ) - @live - type rawResponseRaw + type wrapRawResponseRaw @live - let rawResponseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapRawResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let rawResponseConverterMap = () + type rawResponseRaw @live - let convertRawResponse = v => v->RescriptRelay.convertObj( - rawResponseConverter, - rawResponseConverterMap, - None - ) + let convertRawResponse = value => RescriptRelay.convertWithoutPlan(value, None) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res/src/__generated__/TestMutationWithMultipleTargetsMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationWithMultipleTargetsMutation_graphql.res index bfe2343c8c866..5d2765f52af9a 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationWithMultipleTargetsMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationWithMultipleTargetsMutation_graphql.res @@ -68,73 +68,23 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapRawResponseRaw @live - let wrapRawResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapRawResponseConverterMap = () - @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( - wrapRawResponseConverter, - wrapRawResponseConverterMap, - null - ) + let convertWrapRawResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type rawResponseRaw @live - let rawResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let rawResponseConverterMap = () - @live - let convertRawResponse = v => v->RescriptRelay.convertObj( - rawResponseConverter, - rawResponseConverterMap, - None - ) + let convertRawResponse = value => RescriptRelay.convertWithoutPlan(value, None) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res/src/__generated__/TestMutationWithOnlyFragmentSetOnlineStatusMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationWithOnlyFragmentSetOnlineStatusMutation_graphql.res index bcc700eeb1f36..838d7e701c233 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationWithOnlyFragmentSetOnlineStatusMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationWithOnlyFragmentSetOnlineStatusMutation_graphql.res @@ -67,77 +67,75 @@ let unwrap_rawResponse_setOnlineStatus_user_memberOf: Types.rawResponse_setOnlin let wrap_rawResponse_setOnlineStatus_user_memberOf: Types.rawResponse_setOnlineStatus_user_memberOf => Types.rawResponse_setOnlineStatus_user_memberOf = RescriptRelay_Internal.wrapUnion module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["setOnlineStatus","user"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) @live type wrapRawResponseRaw + %%private( @live - let wrapRawResponseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user_memberOf":{"u":"rawResponse_setOnlineStatus_user_memberOf"}}}` - ) + let wrapRawResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["setOnlineStatus","user","memberOf"],"union":"0"}]},"version":2}`) @live - let wrapRawResponseConverterMap = { - "rawResponse_setOnlineStatus_user_memberOf": wrap_rawResponse_setOnlineStatus_user_memberOf, + let wrapRawResponseCallbacks = { + "0": wrap_rawResponse_setOnlineStatus_user_memberOf, } @live - let convertWrapRawResponse = v => v->RescriptRelay.convertObj( + let preparedWrapRawResponseConverter = RescriptRelay.prepareConversion( wrapRawResponseConverter, - wrapRawResponseConverterMap, + wrapRawResponseCallbacks, null ) + ) + @live + let convertWrapRawResponse = value => RescriptRelay.runConversion(preparedWrapRawResponseConverter, value) @live type rawResponseRaw + %%private( @live - let rawResponseConverter: dict>> = %raw( - json`{"__root":{"setOnlineStatus_user_memberOf":{"u":"rawResponse_setOnlineStatus_user_memberOf"}}}` - ) + let rawResponseConverter = wrapRawResponseConverter @live - let rawResponseConverterMap = { - "rawResponse_setOnlineStatus_user_memberOf": unwrap_rawResponse_setOnlineStatus_user_memberOf, + let rawResponseCallbacks = { + "0": unwrap_rawResponse_setOnlineStatus_user_memberOf, } @live - let convertRawResponse = v => v->RescriptRelay.convertObj( + let preparedRawResponseConverter = RescriptRelay.prepareConversion( rawResponseConverter, - rawResponseConverterMap, + rawResponseCallbacks, None ) + ) + @live + let convertRawResponse = value => RescriptRelay.runConversion(preparedRawResponseConverter, value) } module Utils = { @@warning("-33") diff --git a/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsMutation_graphql.res index b7b85e5fb8230..7b1db8a5ccc77 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsMutation_graphql.res @@ -23,48 +23,30 @@ module Types = { } module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"inputB":{"usingA":{"r":"inputA"},"time":{"c":"SomeModule.Datetime"}},"inputA":{"usingB":{"r":"inputB"},"timestamps":{"b":"a"},"timestamp":{"b":""},"time":{"c":"SomeModule.Datetime"},"recursiveA":{"r":"inputA"}},"__root":{"input":{"r":"inputA"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["input"],"reference":"inputA"}],"inputA":[{"path":["recursiveA"],"reference":"inputA"},{"path":["time"],"scalar":"0"},{"opaque":true,"path":["timestamp"]},{"list":1,"opaque":true,"path":["timestamps"]},{"path":["usingB"],"reference":"inputB"}],"inputB":[{"path":["time"],"scalar":"0"},{"path":["usingA"],"reference":"inputA"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsNullableMutation_graphql.res b/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsNullableMutation_graphql.res index a27a45d3c7213..4dd1799c8e854 100644 --- a/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsNullableMutation_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutationWithRecursiveInputsNullableMutation_graphql.res @@ -23,48 +23,30 @@ module Types = { } module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"inputB":{"usingA":{"r":"inputA"},"time":{"c":"SomeModule.Datetime"}},"inputA":{"usingB":{"r":"inputB"},"timestamps":{"b":"a"},"timestamp":{"b":""},"time":{"c":"SomeModule.Datetime"},"recursiveA":{"r":"inputA"}},"__root":{"input":{"r":"inputA"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["input"],"reference":"inputA"}],"inputA":[{"path":["recursiveA"],"reference":"inputA"},{"path":["time"],"scalar":"0"},{"opaque":true,"path":["timestamp"]},{"list":1,"opaque":true,"path":["timestamps"]},{"path":["usingB"],"reference":"inputB"}],"inputB":[{"path":["time"],"scalar":"0"},{"path":["usingA"],"reference":"inputA"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, null ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestMutation_user_graphql.res b/compiler/test-project-res/src/__generated__/TestMutation_user_graphql.res index 170618f34ffc0..f45fe136c8222 100644 --- a/compiler/test-project-res/src/__generated__/TestMutation_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestMutation_user_graphql.res @@ -33,20 +33,22 @@ let wrap_fragment_memberOf: Types.fragment_memberOf => Types.fragment_memberOf = module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"memberOf":{"u":"fragment_memberOf"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["memberOf"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_memberOf": unwrap_fragment_memberOf, + let fragmentCallbacks = { + "0": unwrap_fragment_memberOf, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnInterfaceQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnInterfaceQuery_graphql.res index 374699f7d09f9..2d60d5adaef7a 100644 --- a/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnInterfaceQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnInterfaceQuery_graphql.res @@ -25,45 +25,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnUnionQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnUnionQuery_graphql.res index 23e3ea500cb7d..bc1a9b8a08e58 100644 --- a/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnUnionQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestNodeInterfaceOnUnionQuery_graphql.res @@ -38,49 +38,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["node"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_node": wrap_response_node, + let wrapResponseCallbacks = { + "0": wrap_response_node, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_node": unwrap_response_node, + let responseCallbacks = { + "0": unwrap_response_node, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestNodeInterfaceQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestNodeInterfaceQuery_graphql.res index fa615c2be85e8..56eba970cbc30 100644 --- a/compiler/test-project-res/src/__generated__/TestNodeInterfaceQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestNodeInterfaceQuery_graphql.res @@ -33,49 +33,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["node"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_node": wrap_response_node, + let wrapResponseCallbacks = { + "0": wrap_response_node, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"u":"response_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_node": unwrap_response_node, + let responseCallbacks = { + "0": unwrap_response_node, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestObserverQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestObserverQuery_graphql.res index d32676d8ef44f..f24f9db75300d 100644 --- a/compiler/test-project-res/src/__generated__/TestObserverQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestObserverQuery_graphql.res @@ -24,45 +24,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestPaginationInNodeQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationInNodeQuery_graphql.res index d76a2c811bb4f..cdf2d722be1dd 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationInNodeQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationInNodeQuery_graphql.res @@ -35,45 +35,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["node"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestPaginationInNodeRefetchQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationInNodeRefetchQuery_graphql.res index faac0330b141a..bdf6e0f8d5c75 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationInNodeRefetchQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationInNodeRefetchQuery_graphql.res @@ -48,45 +48,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["node"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestPaginationInNode_query_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationInNode_query_graphql.res index 122105d00419c..3b4b019f983ea 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationInNode_query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationInNode_query_graphql.res @@ -23,18 +23,20 @@ module Types = { module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"friendsConnection_edges_node":{"f":""}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["friendsConnection","edges"]},{"fragments":true,"path":["friendsConnection","edges","node"]}]},"version":2}`) @live - let fragmentConverterMap = () + let fragmentCallbacks = () @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestPaginationInNode_user_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationInNode_user_graphql.res index d24b57e8106f7..69bcca99f9f40 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationInNode_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationInNode_user_graphql.res @@ -18,17 +18,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestPaginationUnionQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationUnionQuery_graphql.res index 8fd04be1186d5..cce75aac74858 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationUnionQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationUnionQuery_graphql.res @@ -30,45 +30,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":[]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestPaginationUnionRefetchQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationUnionRefetchQuery_graphql.res index 6ca3a86ed24cd..eb4643f13824c 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationUnionRefetchQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationUnionRefetchQuery_graphql.res @@ -43,45 +43,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":[]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestPaginationUnion_query_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationUnion_query_graphql.res index 5216f1163b6d2..14ef33c41b94b 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationUnion_query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationUnion_query_graphql.res @@ -48,20 +48,22 @@ let wrap_fragment_members_edges_node: Types.fragment_members_edges_node => Types module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"members_edges_node_User":{"f":""},"members_edges_node":{"u":"fragment_members_edges_node"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["members","edges"]},{"path":["members","edges","node"],"union":"0"},{"fragments":true,"path":["members","edges","node","User"]}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_members_edges_node": unwrap_fragment_members_edges_node, + let fragmentCallbacks = { + "0": unwrap_fragment_members_edges_node, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestPaginationUnion_user_graphql.res b/compiler/test-project-res/src/__generated__/TestPaginationUnion_user_graphql.res index 881697e72b718..3650655a12708 100644 --- a/compiler/test-project-res/src/__generated__/TestPaginationUnion_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestPaginationUnion_user_graphql.res @@ -17,17 +17,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestProvidedVariablesQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestProvidedVariablesQuery_graphql.res index 6c21a60db4295..d1f66727c7307 100644 --- a/compiler/test-project-res/src/__generated__/TestProvidedVariablesQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestProvidedVariablesQuery_graphql.res @@ -26,48 +26,54 @@ module Types = { type queryRef module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"someInput":{"recursive":{"r":"someInput"},"datetime":{"c":"SomeModule.Datetime"}},"inputA":{"usingB":{"r":"inputB"},"timestamps":{"b":"a"},"timestamp":{"b":""},"time":{"c":"SomeModule.Datetime"},"recursiveA":{"r":"inputA"}},"inputB":{"usingA":{"r":"inputA"},"time":{"c":"SomeModule.Datetime"}},"__root":{"__relay_internal__pv__TestProvidedVariablesSomeInput":{"r":"someInput"},"__relay_internal__pv__TestProvidedVariablesInputB":{"r":"inputB"},"__relay_internal__pv__TestProvidedVariablesDatetimes":{"ca":"SomeModule.Datetime"},"__relay_internal__pv__TestProvidedVariablesDatetime":{"c":"SomeModule.Datetime"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["__relay_internal__pv__TestProvidedVariablesDatetime"],"scalar":"0"},{"list":1,"path":["__relay_internal__pv__TestProvidedVariablesDatetimes"],"scalar":"0"},{"path":["__relay_internal__pv__TestProvidedVariablesInputB"],"reference":"inputB"},{"path":["__relay_internal__pv__TestProvidedVariablesSomeInput"],"reference":"someInput"}],"inputA":[{"path":["recursiveA"],"reference":"inputA"},{"path":["time"],"scalar":"0"},{"opaque":true,"path":["timestamp"]},{"list":1,"opaque":true,"path":["timestamps"]},{"path":["usingB"],"reference":"inputB"}],"inputB":[{"path":["time"],"scalar":"0"},{"path":["usingA"],"reference":"inputA"}],"someInput":[{"path":["datetime"],"scalar":"0"},{"path":["recursive"],"reference":"someInput"}]},"version":2}`) @live - let variablesConverterMap = { - "SomeModule.Datetime": SomeModule.Datetime.serialize, + let variablesCallbacks = { + "0": SomeModule.Datetime.serialize, } @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) + ) + @live + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestProvidedVariables_user_graphql.res b/compiler/test-project-res/src/__generated__/TestProvidedVariables_user_graphql.res index f6cc581cee92b..515d4924b1ceb 100644 --- a/compiler/test-project-res/src/__generated__/TestProvidedVariables_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestProvidedVariables_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestQueryInputObjQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestQueryInputObjQuery_graphql.res index dbf9f3459d776..9efdfcb49be1b 100644 --- a/compiler/test-project-res/src/__generated__/TestQueryInputObjQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestQueryInputObjQuery_graphql.res @@ -30,46 +30,28 @@ module Types = { type queryRef module Internal = { + %%private( @live - let variablesConverter: dict>> = %raw( - json`{"pesticideListSearchInput":{},"__root":{"input":{"r":"pesticideListSearchInput"}}}` - ) + let variablesConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["input"],"reference":"pesticideListSearchInput"}],"pesticideListSearchInput":[]},"version":2}`) @live - let variablesConverterMap = () + let variablesCallbacks = () @live - let convertVariables = v => v->RescriptRelay.convertObj( + let preparedVariablesConverter = RescriptRelay.prepareConversion( variablesConverter, - variablesConverterMap, + variablesCallbacks, None ) - @live - type wrapResponseRaw - @live - let wrapResponseConverter: dict>> = %raw( - json`{}` ) @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertVariables = value => RescriptRelay.runConversion(preparedVariablesConverter, value) @live - type responseRaw + type wrapResponseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live - let responseConverterMap = () + type responseRaw @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestQueryWithRequiredQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestQueryWithRequiredQuery_graphql.res index 2b68fe961db75..99d76a354cc61 100644 --- a/compiler/test-project-res/src/__generated__/TestQueryWithRequiredQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestQueryWithRequiredQuery_graphql.res @@ -24,45 +24,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestQueryWithRequired_BubbleToTop_Query_graphql.res b/compiler/test-project-res/src/__generated__/TestQueryWithRequired_BubbleToTop_Query_graphql.res index 5f67644aee84b..eb36a640f92c4 100644 --- a/compiler/test-project-res/src/__generated__/TestQueryWithRequired_BubbleToTop_Query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestQueryWithRequired_BubbleToTop_Query_graphql.res @@ -25,45 +25,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestQuery_graphql.res index d54c82daf2e88..8e958b02cc5ff 100644 --- a/compiler/test-project-res/src/__generated__/TestQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestQuery_graphql.res @@ -42,45 +42,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingInNodeQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingInNodeQuery_graphql.res index 26998f0174779..6273e37a1ae39 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingInNodeQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingInNodeQuery_graphql.res @@ -42,49 +42,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node_User":{"f":""},"node":{"u":"response_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["node"],"union":"0"},{"fragments":true,"path":["node","User"]}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_node": wrap_response_node, + let wrapResponseCallbacks = { + "0": wrap_response_node, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node_User":{"f":""},"node":{"u":"response_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_node": unwrap_response_node, + let responseCallbacks = { + "0": unwrap_response_node, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingInNodeRefetchQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingInNodeRefetchQuery_graphql.res index 43cc5f9538465..ec259f48d640e 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingInNodeRefetchQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingInNodeRefetchQuery_graphql.res @@ -44,45 +44,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["node"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingInNode_user_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingInNode_user_graphql.res index 3e73b3cba126e..9dfa887e9f185 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingInNode_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingInNode_user_graphql.res @@ -19,17 +19,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingNoArgsRefetchQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingNoArgsRefetchQuery_graphql.res index dbc361d53e1ac..68013b4cc18b5 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingNoArgsRefetchQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingNoArgsRefetchQuery_graphql.res @@ -22,45 +22,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":[]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingNoArgs_query_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingNoArgs_query_graphql.res index e45518d3207e9..de97241986003 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingNoArgs_query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingNoArgs_query_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingQuery_graphql.res index 3c6cc9d870ee3..b19a1ae06df8b 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingQuery_graphql.res @@ -24,45 +24,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetchingRefetchQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetchingRefetchQuery_graphql.res index 3998ea97ce137..fa3a4edf89db8 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetchingRefetchQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetchingRefetchQuery_graphql.res @@ -44,45 +44,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["node"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"node":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestRefetching_user_graphql.res b/compiler/test-project-res/src/__generated__/TestRefetching_user_graphql.res index 2a96ced9a281c..f3b22f9210cc6 100644 --- a/compiler/test-project-res/src/__generated__/TestRefetching_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRefetching_user_graphql.res @@ -19,17 +19,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestRelayResolverMultiFancyGreeting_graphql.res b/compiler/test-project-res/src/__generated__/TestRelayResolverMultiFancyGreeting_graphql.res index ad4f4f9c9913b..fc68f7e053ec0 100644 --- a/compiler/test-project-res/src/__generated__/TestRelayResolverMultiFancyGreeting_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRelayResolverMultiFancyGreeting_graphql.res @@ -13,17 +13,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestRelayResolver_graphql.res b/compiler/test-project-res/src/__generated__/TestRelayResolver_graphql.res index b27f6b68b317c..dec236f87bafc 100644 --- a/compiler/test-project-res/src/__generated__/TestRelayResolver_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRelayResolver_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestRelayResolversAllQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestRelayResolversAllQuery_graphql.res index 379d173fa3c8e..0c3ffc5ae6cc1 100644 --- a/compiler/test-project-res/src/__generated__/TestRelayResolversAllQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestRelayResolversAllQuery_graphql.res @@ -28,45 +28,15 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw @live - let wrapResponseConverter: dict>> = %raw( - json`{}` - ) - @live - let wrapResponseConverterMap = () - @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( - wrapResponseConverter, - wrapResponseConverterMap, - null - ) + let convertWrapResponse = value => RescriptRelay.convertWithoutPlan(value, null) @live type responseRaw @live - let responseConverter: dict>> = %raw( - json`{}` - ) - @live - let responseConverterMap = () - @live - let convertResponse = v => v->RescriptRelay.convertObj( - responseConverter, - responseConverterMap, - None - ) + let convertResponse = value => RescriptRelay.convertWithoutPlan(value, None) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_fragment_graphql.res b/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_fragment_graphql.res index 445262759f888..e1647a8394609 100644 --- a/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_fragment_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_fragment_graphql.res @@ -25,20 +25,22 @@ let wrap_fragment_localUnion: Types.fragment_localUnion => Types.fragment_localU module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"localUnion":{"u":"fragment_localUnion"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["localUnion"],"union":"0"}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment_localUnion": unwrap_fragment_localUnion, + let fragmentCallbacks = { + "0": unwrap_fragment_localUnion, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_graphql.res index b0a9ab150fad5..660925f0efea8 100644 --- a/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestSchemaExtensionsQuery_graphql.res @@ -34,49 +34,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"localUnion":{"u":"response_localUnion"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["localUnion"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_localUnion": wrap_response_localUnion, + let wrapResponseCallbacks = { + "0": wrap_response_localUnion, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"localUnion":{"u":"response_localUnion"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_localUnion": unwrap_response_localUnion, + let responseCallbacks = { + "0": unwrap_response_localUnion, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestSubscriptionQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestSubscriptionQuery_graphql.res index d3d7ce89146fd..219a0880d2c19 100644 --- a/compiler/test-project-res/src/__generated__/TestSubscriptionQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestSubscriptionQuery_graphql.res @@ -24,45 +24,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestSubscriptionUserUpdatedSubscription_graphql.res b/compiler/test-project-res/src/__generated__/TestSubscriptionUserUpdatedSubscription_graphql.res index eb35c38e3a199..7e265ecce4597 100644 --- a/compiler/test-project-res/src/__generated__/TestSubscriptionUserUpdatedSubscription_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestSubscriptionUserUpdatedSubscription_graphql.res @@ -28,31 +28,23 @@ module Types = { module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"userUpdated_user":{"f":""}}}` - ) + let responseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["userUpdated","user"]}]},"version":2}`) @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type rawResponseRaw = responseRaw @live let convertRawResponse = convertResponse diff --git a/compiler/test-project-res/src/__generated__/TestSubscription_user_graphql.res b/compiler/test-project-res/src/__generated__/TestSubscription_user_graphql.res index 31f8a71609a7d..9289173579d63 100644 --- a/compiler/test-project-res/src/__generated__/TestSubscription_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestSubscription_user_graphql.res @@ -16,17 +16,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestUnionFragmentExhaustiveQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionFragmentExhaustiveQuery_graphql.res index 066abe69ccb50..cba5f86e602d5 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionFragmentExhaustiveQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionFragmentExhaustiveQuery_graphql.res @@ -33,49 +33,43 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"response_member"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":["member"],"union":"0"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_member": wrap_response_member, + let wrapResponseCallbacks = { + "0": wrap_response_member, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"member":{"u":"response_member"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_member": unwrap_response_member, + let responseCallbacks = { + "0": unwrap_response_member, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestUnionFragmentQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionFragmentQuery_graphql.res index 97e1cf368822d..4cc00f156346a 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionFragmentQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionFragmentQuery_graphql.res @@ -25,45 +25,39 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"member":{"f":""}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["member"]}]},"version":2}`) @live - let wrapResponseConverterMap = () + let wrapResponseCallbacks = () @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"member":{"f":""}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = () + let responseCallbacks = () @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestUnionFragmentUser_user_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionFragmentUser_user_graphql.res index 977fec2da7fc5..3083591213beb 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionFragmentUser_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionFragmentUser_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/TestUnionFragment_member_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionFragment_member_graphql.res index 4e402be683c01..9a6396efbe4e8 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionFragment_member_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionFragment_member_graphql.res @@ -28,20 +28,22 @@ let wrap_fragment: Types.fragment => Types.fragment = RescriptRelay_Internal.wra module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"User":{"f":""},"":{"u":"fragment"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":[],"union":"0"},{"fragments":true,"path":["User"]}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment": unwrap_fragment, + let fragmentCallbacks = { + "0": unwrap_fragment, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestUnionFragment_plural_member_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionFragment_plural_member_graphql.res index 71088d52c4c4c..855323b25671f 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionFragment_plural_member_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionFragment_plural_member_graphql.res @@ -29,20 +29,22 @@ let wrap_fragment: Types.fragment => Types.fragment = RescriptRelay_Internal.wra module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"User":{"f":""},"":{"u":"fragment"}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"path":[],"union":"0"},{"fragments":true,"path":["User"]}]},"version":2}`) @live - let fragmentConverterMap = { - "fragment": unwrap_fragment, + let fragmentCallbacks = { + "0": unwrap_fragment, } @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestUnionsQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestUnionsQuery_graphql.res index c353d74cb6f11..18bd69e19e368 100644 --- a/compiler/test-project-res/src/__generated__/TestUnionsQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUnionsQuery_graphql.res @@ -76,51 +76,45 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) @live type wrapResponseRaw + %%private( @live - let wrapResponseConverter: dict>> = %raw( - json`{"__root":{"members_edges_node_Group_members":{"u":"response_members_edges_node_Group_members"},"members_edges_node":{"u":"response_members_edges_node"}}}` - ) + let wrapResponseConverter: JSON.t = %raw(json`{"roots":{"__root":[{"list":1,"path":["members","edges"]},{"path":["members","edges","node"],"union":"0"},{"list":1,"path":["members","edges","node","Group","members"],"union":"1"}]},"version":2}`) @live - let wrapResponseConverterMap = { - "response_members_edges_node_Group_members": wrap_response_members_edges_node_Group_members, - "response_members_edges_node": wrap_response_members_edges_node, + let wrapResponseCallbacks = { + "0": wrap_response_members_edges_node, + "1": wrap_response_members_edges_node_Group_members, } @live - let convertWrapResponse = v => v->RescriptRelay.convertObj( + let preparedWrapResponseConverter = RescriptRelay.prepareConversion( wrapResponseConverter, - wrapResponseConverterMap, + wrapResponseCallbacks, null ) + ) + @live + let convertWrapResponse = value => RescriptRelay.runConversion(preparedWrapResponseConverter, value) @live type responseRaw + %%private( @live - let responseConverter: dict>> = %raw( - json`{"__root":{"members_edges_node_Group_members":{"u":"response_members_edges_node_Group_members"},"members_edges_node":{"u":"response_members_edges_node"}}}` - ) + let responseConverter = wrapResponseConverter @live - let responseConverterMap = { - "response_members_edges_node_Group_members": unwrap_response_members_edges_node_Group_members, - "response_members_edges_node": unwrap_response_members_edges_node, + let responseCallbacks = { + "0": unwrap_response_members_edges_node, + "1": unwrap_response_members_edges_node_Group_members, } @live - let convertResponse = v => v->RescriptRelay.convertObj( + let preparedResponseConverter = RescriptRelay.prepareConversion( responseConverter, - responseConverterMap, + responseCallbacks, None ) + ) + @live + let convertResponse = value => RescriptRelay.runConversion(preparedResponseConverter, value) type wrapRawResponseRaw = wrapResponseRaw @live let convertWrapRawResponse = convertWrapResponse diff --git a/compiler/test-project-res/src/__generated__/TestUpdatableFragments_query_graphql.res b/compiler/test-project-res/src/__generated__/TestUpdatableFragments_query_graphql.res index 76520a9a58449..90e0684c50178 100644 --- a/compiler/test-project-res/src/__generated__/TestUpdatableFragments_query_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUpdatableFragments_query_graphql.res @@ -17,18 +17,20 @@ module Types = { module Internal = { @live type fragmentRaw + %%private( @live - let fragmentConverter: dict>> = %raw( - json`{"__root":{"loggedInUser":{"f":""}}}` - ) + let fragmentConverter: JSON.t = %raw(json`{"roots":{"__root":[{"fragments":true,"path":["loggedInUser"]}]},"version":2}`) @live - let fragmentConverterMap = () + let fragmentCallbacks = () @live - let convertFragment = v => v->RescriptRelay.convertObj( + let preparedFragmentConverter = RescriptRelay.prepareConversion( fragmentConverter, - fragmentConverterMap, + fragmentCallbacks, None ) + ) + @live + let convertFragment = value => RescriptRelay.runConversion(preparedFragmentConverter, value) } type t diff --git a/compiler/test-project-res/src/__generated__/TestUpdatableQuery_graphql.res b/compiler/test-project-res/src/__generated__/TestUpdatableQuery_graphql.res index 42966195ceb99..5555353a36f31 100644 --- a/compiler/test-project-res/src/__generated__/TestUpdatableQuery_graphql.res +++ b/compiler/test-project-res/src/__generated__/TestUpdatableQuery_graphql.res @@ -21,17 +21,7 @@ type queryRef module Internal = { @live - let variablesConverter: dict>> = %raw( - json`{}` - ) - @live - let variablesConverterMap = () - @live - let convertVariables = v => v->RescriptRelay.convertObj( - variablesConverter, - variablesConverterMap, - None - ) + let convertVariables = value => RescriptRelay.convertWithoutPlan(value, None) } diff --git a/compiler/test-project-res/src/__generated__/UserAvatar_user_graphql.res b/compiler/test-project-res/src/__generated__/UserAvatar_user_graphql.res index e8a9be0d576cd..f3ce1402c9ffc 100644 --- a/compiler/test-project-res/src/__generated__/UserAvatar_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/UserAvatar_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/UserMeta____relay_model_instance_graphql.res b/compiler/test-project-res/src/__generated__/UserMeta____relay_model_instance_graphql.res index 8452e7810446c..e2c4ca3550577 100644 --- a/compiler/test-project-res/src/__generated__/UserMeta____relay_model_instance_graphql.res +++ b/compiler/test-project-res/src/__generated__/UserMeta____relay_model_instance_graphql.res @@ -11,17 +11,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/UserName_user_graphql.res b/compiler/test-project-res/src/__generated__/UserName_user_graphql.res index 760a1274bc6c7..6780204dacd4c 100644 --- a/compiler/test-project-res/src/__generated__/UserName_user_graphql.res +++ b/compiler/test-project-res/src/__generated__/UserName_user_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t diff --git a/compiler/test-project-res/src/__generated__/UserNode_node_graphql.res b/compiler/test-project-res/src/__generated__/UserNode_node_graphql.res index 2acecd9a88d8a..0e1de1aa7d55e 100644 --- a/compiler/test-project-res/src/__generated__/UserNode_node_graphql.res +++ b/compiler/test-project-res/src/__generated__/UserNode_node_graphql.res @@ -14,17 +14,7 @@ module Internal = { @live type fragmentRaw @live - let fragmentConverter: dict>> = %raw( - json`{}` - ) - @live - let fragmentConverterMap = () - @live - let convertFragment = v => v->RescriptRelay.convertObj( - fragmentConverter, - fragmentConverterMap, - None - ) + let convertFragment = value => RescriptRelay.convertWithoutPlan(value, None) } type t