partial

src/cli/tc/init.rs

@@ -9,6 +9,7 @@ use crate::core::config::{Config, Expr, Field, Resolver, RootSchema, Source};
 use crate::core::merge_right::MergeRight;
 use crate::core::runtime::TargetRuntime;
 use crate::core::{config, Type};
+use crate::core::valid::Validator;
 
 pub(super) async fn init_command(runtime: TargetRuntime, folder_path: &str) -> Result<()> {
     create_directory(folder_path).await?;
@@ -61,7 +62,7 @@ async fn confirm_and_write_yml(
     match runtime.file.read(yml_file_path.as_ref()).await {
         Ok(yml_content) => {
             let graphqlrc: serde_yaml::Value = serde_yaml::from_str(&yml_content)?;
-            final_graphqlrc = graphqlrc.merge_right(final_graphqlrc);
+            final_graphqlrc = graphqlrc.merge_right(final_graphqlrc).to_result()?;
             let content = serde_yaml::to_string(&final_graphqlrc)?;
             confirm_and_write(runtime.clone(), &yml_file_path, content.as_bytes()).await
         }

src/core/config/config.rs

@@ -280,8 +280,8 @@ pub struct Field {
 
 // It's a terminal implementation of MergeRight
 impl MergeRight for Field {
-    fn merge_right(self, other: Self) -> Self {
-        other
+    fn merge_right(self, other: Self) -> Valid<Self, String> {
+        Valid::succeed(other)
     }
 }
 

src/core/config/config_module.rs

@@ -48,8 +48,8 @@ impl From<Config> for Cache {
 }
 
 impl MergeRight for Cache {
-    fn merge_right(self, other: Self) -> Self {
-        Cache::from(self.config.merge_right(other.config))
+    fn merge_right(self, other: Self) -> Valid<Self, String> {
+        self.config.merge_right(other.config).map(Cache::from)
     }
 }
 
@@ -63,11 +63,6 @@ impl ConfigModule {
         self
     }
 
-    pub fn merge_extensions(mut self, extensions: Extensions) -> Self {
-        self.extensions = self.extensions.merge_right(extensions);
-        self
-    }
-
     pub fn config(&self) -> &Config {
         &self.cache.config
     }
@@ -151,10 +146,9 @@ impl Extensions {
 }
 
 impl MergeRight for FileDescriptorSet {
-    fn merge_right(mut self, other: Self) -> Self {
+    fn merge_right(mut self, other: Self) -> Valid<Self, String> {
         self.file.extend(other.file);
-
-        self
+        Valid::succeed(self)
     }
 }
 

src/core/config/cors.rs

@@ -5,6 +5,9 @@ use crate::core::http::Method;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Valid;
+use crate::core::valid::Validator;
+
 
 /// Type to configure Cross-Origin Resource Sharing (CORS) for a server.
 #[derive(

src/core/config/headers.rs

@@ -7,6 +7,8 @@ use crate::core::config::KeyValue;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Valid;
+use crate::core::valid::Validator;
 
 #[derive(
     Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,

src/core/config/key_values.rs

@@ -2,8 +2,11 @@ use std::collections::BTreeMap;
 use std::ops::Deref;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use tailcall_macros::MergeRight;
+use crate::core::valid::{Valid,Validator};
+use crate::core::merge_right::MergeRight;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, schemars::JsonSchema)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, MergeRight, schemars::JsonSchema)]
 pub struct KeyValues(pub BTreeMap<String, String>);
 
 impl Deref for KeyValues {
@@ -20,7 +23,7 @@ impl FromIterator<(String, String)> for KeyValues {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default, Eq, PartialEq, schemars::JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default, Eq, PartialEq, schemars::JsonSchema, MergeRight)]
 pub struct KeyValue {
     pub key: String,
     pub value: String,

src/core/config/reader.rs

@@ -14,6 +14,7 @@ use crate::core::proto_reader::ProtoReader;
 use crate::core::resource_reader::{Cached, Resource, ResourceReader};
 use crate::core::rest::EndpointSet;
 use crate::core::runtime::TargetRuntime;
+use crate::core::valid::Validator;
 
 /// Reads the configuration from a file or from an HTTP URL and resolves all
 /// linked extensions to create a ConfigModule.
@@ -69,13 +70,13 @@ impl ConfigReader {
                     let content = source.content;
 
                     let config = Config::from_source(Source::detect(&source.path)?, &content)?;
-                    config_module = config_module.merge_right(config.clone().into());
+                    config_module = config_module.merge_right(config.clone().into()).to_result()?;
 
                     if !config.links.is_empty() {
                         let cfg_module = self
                             .ext_links(ConfigModule::from(config), Path::new(&link.src).parent())
                             .await?;
-                        config_module = config_module.merge_right(cfg_module.clone());
+                        config_module = config_module.merge_right(cfg_module.clone()).to_result()?;
                     }
                 }
                 LinkType::Protobuf => {
@@ -183,7 +184,6 @@ impl ConfigReader {
     ) -> anyhow::Result<ConfigModule> {
         let files = self.resource_reader.read_files(files).await?;
         let mut config_module = ConfigModule::default();
-
         for file in files.iter() {
             let source = Source::detect(&file.path)?;
             let schema = &file.content;
@@ -197,7 +197,7 @@ impl ConfigReader {
                 .await?;
 
             // Merge it with the original config set
-            config_module = config_module.merge_right(new_config_module);
+            config_module = config_module.merge_right(new_config_module).to_result()?;
         }
 
         Ok(config_module)

src/core/config/server.rs

@@ -9,6 +9,9 @@ use crate::core::config::KeyValue;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Valid;
+use crate::core::valid::Validator;
+
 
 #[derive(
     Serialize,

src/core/config/telemetry.rs

@@ -10,6 +10,7 @@ use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
 use crate::core::mustache::Mustache;
 use crate::core::valid::Validator;
+use crate::core::valid::Valid;
 
 mod defaults {
     pub mod prometheus {
@@ -79,6 +80,7 @@ pub enum TelemetryExporter {
     schemars::JsonSchema,
     DirectiveDefinition,
     InputDefinition,
+    MergeRight,
 )]
 #[directive_definition(locations = "Schema")]
 #[serde(deny_unknown_fields)]
@@ -103,7 +105,7 @@ impl Telemetry {
             (None, None) => None,
             (None, Some(export)) => Some(export),
             (Some(export), None) => Some(export.clone()),
-            (Some(left), Some(right)) => Some(left.clone().merge_right(right.clone())),
+            (Some(left), Some(right)) => left.clone().merge_right(right.clone()).to_result().ok(),
         };
         self.request_headers.extend(other.request_headers);
 

src/core/config/transformer/merge_types/type_merger.rs

@@ -196,27 +196,40 @@ impl TypeMerger {
 
 fn merge_type(type_: &Type, mut merge_into: Type) -> Type {
     // Merge the simple fields using `merge_right`.
-    merge_into.added_fields = merge_into
+     let mut merge_into = merge_into
         .added_fields
-        .merge_right(type_.added_fields.clone());
-    merge_into.implements = merge_into.implements.merge_right(type_.implements.clone());
-    merge_into.cache = merge_into.cache.merge_right(type_.cache.clone());
-    merge_into.protected = merge_into.protected.merge_right(type_.protected.clone());
-    merge_into.doc = merge_into.doc.merge_right(type_.doc.clone());
+         .clone()
+        .merge_right(type_.added_fields.clone()).and_then(|fields| {
+         merge_into.implements.clone().merge_right(type_.implements.clone()).map(|implements| (fields, implements))
+     }).and_then(|(fields, implements)| {
+         merge_into.cache.clone().merge_right(type_.cache.clone()).map(|cache| (fields, implements, cache))
+     }).and_then(|(fields, implements, cache)| {
+         merge_into.protected.clone().merge_right(type_.protected.clone()).map(|protected| (fields, implements, cache, protected))
+     }).and_then(|(fields, implements, cache, protected)| {
+         merge_into.doc.clone().merge_right(type_.doc.clone()).map(|doc| (fields, implements, cache, protected, doc))
+     }).and_then(|(fields, implements, cache, protected, doc)| {
+         merge_into.added_fields = fields;
+         merge_into.implements = implements;
+         merge_into.cache = cache;
+         merge_into.protected = protected;
+         merge_into.doc = doc;
+         Valid::succeed(merge_into)
+     }).to_result().unwrap_or_default();
 
     // Handle field output type merging correctly.
     type_.fields.iter().for_each(|(key, new_field)| {
         merge_into
             .fields
             .entry(key.to_owned())
             .and_modify(|existing_field| {
-                let mut merged_field = existing_field.clone().merge_right(new_field.clone());
-                if existing_field.type_of.name() == &Scalar::JSON.to_string()
-                    || new_field.type_of.name() == &Scalar::JSON.to_string()
-                {
-                    merged_field.type_of = Scalar::JSON.to_string().into();
-                }
-                *existing_field = merged_field;
+                existing_field.clone().merge_right(new_field.clone()).map(|mut merged_field| {
+                    if existing_field.type_of.name() == &Scalar::JSON.to_string()
+                        || new_field.type_of.name() == &Scalar::JSON.to_string()
+                    {
+                        merged_field.type_of = Scalar::JSON.to_string().into();
+                    }
+                    *existing_field = merged_field;
+                }).to_result().unwrap_or_default();
             })
             .or_insert_with(|| new_field.to_owned());
     });

src/core/config/upstream.rs

@@ -7,6 +7,8 @@ use tailcall_macros::{DirectiveDefinition, InputDefinition};
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Validator;
+use crate::core::valid::Valid;
 
 const DEFAULT_MAX_SIZE: usize = 100;
 

src/core/generator/from_json.rs

@@ -132,10 +132,17 @@ impl Transform for FromJsonGenerator<'_> {
                 .pipe(RenameTypes::new(rename_types.into_iter()))
                 .transform(config.clone())
         })
-        .map(|configs| {
-            configs
-                .iter()
-                .fold(config, |acc, c| acc.merge_right(c.clone()))
+        .and_then(|configs| {
+            let mut config = Config::default();
+            for c in configs {
+                config.clone().merge_right(c).map(|c| config = c).to_result();
+            }
+
+            Valid::succeed(config)
+
+            // configs
+            //     .iter()
+            //     .fold(config, |acc, c| acc.merge_right(c.clone()))
         })
     }
 }

src/core/generator/generator.rs

@@ -102,7 +102,7 @@ impl Generator {
         for input in self.inputs.iter() {
             match input {
                 Input::Config { source, schema } => {
-                    config = config.merge_right(Config::from_source(source.clone(), schema)?);
+                    config = config.merge_right(Config::from_source(source.clone(), schema)?).to_result()?;
                 }
                 Input::Json {
                     url,
@@ -124,11 +124,11 @@ impl Generator {
                     .with_req_body(req_body.to_owned());
 
                     config = config
-                        .merge_right(self.generate_from_json(&type_name_generator, &[req_sample])?);
+                        .merge_right(self.generate_from_json(&type_name_generator, &[req_sample])?).to_result()?;
                 }
                 Input::Proto(proto_input) => {
                     config =
-                        config.merge_right(self.generate_from_proto(proto_input, &self.query)?);
+                        config.merge_right(self.generate_from_proto(proto_input, &self.query)?).to_result()?;
                 }
             }
         }

src/core/jit/builder.rs

@@ -15,7 +15,6 @@ use super::BuildError;
 use crate::core::blueprint::{Blueprint, Index, QueryField};
 use crate::core::counter::{Count, Counter};
 use crate::core::jit::model::OperationPlan;
-use crate::core::merge_right::MergeRight;
 use crate::core::Type;
 
 #[derive(PartialEq, strum_macros::Display)]
@@ -231,7 +230,7 @@ impl Builder {
                         };
 
                         fields.push(flat_field);
-                        fields = fields.merge_right(child_fields);
+                        fields.extend(child_fields);
                     } else if field_name == "__typename" {
                         let flat_field = Field {
                             id: FieldId::new(self.field_id.next()),

src/core/jit/graphql_executor.rs

@@ -10,6 +10,7 @@ use crate::core::http::RequestContext;
 use crate::core::jit;
 use crate::core::jit::ConstValueExecutor;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Validator;
 
 #[derive(Clone)]
 pub struct JITExecutor {
@@ -60,7 +61,7 @@ impl Executor for JITExecutor {
                         let async_req =
                             async_graphql::Request::from(jit_request).only_introspection();
                         let async_resp = self.app_ctx.execute(async_req).await;
-                        jit_resp.merge_right(async_resp)
+                        jit_resp.merge_right(async_resp).to_result().unwrap_or_default()
                     } else {
                         jit_resp
                     }

src/core/jit/response.rs

@@ -6,6 +6,7 @@ use serde::Serialize;
 use super::Positioned;
 use crate::core::jit;
 use crate::core::merge_right::MergeRight;
+use crate::core::valid::Valid;
 
 #[derive(Setters, Serialize)]
 pub struct Response<Value, Error> {
@@ -35,7 +36,7 @@ impl<Value, Error> Response<Value, Error> {
 }
 
 impl MergeRight for async_graphql::Response {
-    fn merge_right(mut self, other: Self) -> Self {
+    fn merge_right(mut self, other: Self) -> Valid<Self, String> {
         if let async_graphql::Value::Object(mut other_obj) = other.data {
             if let async_graphql::Value::Object(self_obj) = std::mem::take(self.data.borrow_mut()) {
                 other_obj.extend(self_obj);
@@ -46,7 +47,7 @@ impl MergeRight for async_graphql::Response {
         self.errors.extend(other.errors);
         self.extensions.extend(other.extensions);
 
-        self
+        Valid::succeed(self)
     }
 }
 
@@ -70,6 +71,7 @@ mod test {
     use super::Response;
     use crate::core::jit::{self, Pos, Positioned};
     use crate::core::merge_right::MergeRight;
+    use crate::core::valid::Validator;
 
     #[test]
     fn test_with_response() {
@@ -178,7 +180,10 @@ mod test {
             ConstValue::from_json(serde_json::from_str(user_response).unwrap()).unwrap();
         let query_response = async_graphql::Response::new(user_data);
 
-        let merged_response = introspection_response.merge_right(query_response);
+        let merged_response = introspection_response
+            .merge_right(query_response)
+            .to_result()
+            .unwrap();
 
         insta::assert_json_snapshot!(merged_response);
     }
@@ -196,7 +201,7 @@ mod test {
         )];
         resp2.errors.append(&mut err2);
 
-        let merged_resp = resp1.merge_right(resp2);
+        let merged_resp = resp1.merge_right(resp2).to_result().unwrap();
         insta::assert_json_snapshot!(merged_resp);
     }
 }