refactor: Clean up JSON Like (#2423)

benches/request_template_bench.rs

@@ -33,7 +33,7 @@ impl PathValue for Context {
 }
 
 impl PathString for Context {
-    fn path_string<T: AsRef<str>>(&self, parts: &[T]) -> Option<Cow<'_, str>> {
+    fn path_string<'a, T: AsRef<str>>(&'a self, parts: &'a [T]) -> Option<Cow<'_, str>> {
         self.value.path_string(parts)
     }
 }

project-words.txt

@@ -3,6 +3,7 @@ entr
 Hasher
 Htpasswd
 httpmock
+indexmap
 inlines
 insta
 jsonplaceholder

src/core/blueprint/definitions.rs

@@ -264,7 +264,7 @@ fn update_args<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
         move |(_, field, _typ, name), _| {
-            // TODO! assert type name
+            // TODO: assert type name
             Valid::from_iter(field.args.iter(), |(name, arg)| {
                 Valid::succeed(InputFieldDefinition {
                     name: name.clone(),

src/core/grpc/request_template.rs

@@ -199,7 +199,7 @@ mod tests {
     }
 
     impl crate::core::path::PathString for Context {
-        fn path_string<T: AsRef<str>>(&self, parts: &[T]) -> Option<Cow<'_, str>> {
+        fn path_string<'a, T: AsRef<str>>(&'a self, parts: &'a [T]) -> Option<Cow<'_, str>> {
             self.value.path_string(parts)
         }
     }
@@ -283,7 +283,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_grpc_cache_key_collision() {
-        let tmpls = [
+        let arr = [
             r#"{ "name": "test" }"#,
             r#"{ "name": "test1" }"#,
             r#"{ "name1": "test" }"#,
@@ -292,7 +292,7 @@ mod tests {
 
         let ctx = Context::default();
         let tmpl_set: HashSet<_> =
-            futures_util::future::join_all(tmpls.iter().cloned().zip(std::iter::repeat(&ctx)).map(
+            futures_util::future::join_all(arr.iter().cloned().zip(std::iter::repeat(&ctx)).map(
                 |(body_str, ctx)| async {
                     let tmpl = request_template_with_body(body_str).await;
                     tmpl.cache_key(ctx)
@@ -302,6 +302,6 @@ mod tests {
             .into_iter()
             .collect();
 
-        assert_eq!(tmpls.len(), tmpl_set.len());
+        assert_eq!(arr.len(), tmpl_set.len());
     }
 }

src/core/http/request_template.rs

@@ -327,7 +327,7 @@ mod tests {
     }
 
     impl crate::core::path::PathString for Context {
-        fn path_string<T: AsRef<str>>(&self, parts: &[T]) -> Option<Cow<'_, str>> {
+        fn path_string<'a, T: AsRef<str>>(&'a self, parts: &'a [T]) -> Option<Cow<'_, str>> {
             self.value.path_string(parts)
         }
     }

src/core/jit/exec.rs

@@ -22,7 +22,7 @@ pub struct Executor<Synth, IRExec> {
 
 impl<Input: Clone, Output, Error, Synth, Exec> Executor<Synth, Exec>
 where
-    Output: JsonLike<Json = Output> + Debug,
+    Output: for<'a> JsonLike<'a> + Debug,
     Synth: Synthesizer<Value = Result<Output, Error>, Variable = Input>,
     Exec: IRExecutor<Input = Input, Output = Output, Error = Error>,
 {
@@ -56,7 +56,7 @@ struct ExecutorInner<'a, Input, Output, Error, Exec> {
 
 impl<'a, Input, Output, Error, Exec> ExecutorInner<'a, Input, Output, Error, Exec>
 where
-    Output: JsonLike<Json = Output> + Debug,
+    Output: for<'i> JsonLike<'i> + Debug,
     Exec: IRExecutor<Input = Input, Output = Output, Error = Error>,
 {
     fn new(
@@ -93,7 +93,7 @@ where
                     if let Ok(array) = value.as_array_ok() {
                         join_all(field.nested().iter().map(|field| {
                             join_all(array.iter().enumerate().map(|(index, value)| {
-                                let ctx = ctx.with_value(value);
+                                let ctx = ctx.with_value(value); // Output::JsonArray::Value
                                 let data_path = data_path.clone().with_index(index);
                                 async move { self.execute(field, &ctx, data_path).await }
                             }))

src/core/jit/synth/mod.rs

@@ -8,7 +8,7 @@ use super::{Store, Variables};
 use crate::core::json::JsonLike;
 pub trait Synthesizer {
     type Value;
-    type Variable: JsonLike;
+    type Variable: for<'a> JsonLike<'a>;
     fn synthesize(
         self,
         store: Store<Self::Value>,

src/core/json/borrow.rs

@@ -0,0 +1,92 @@
+use serde_json_borrow::{ObjectAsVec, Value};
+
+use super::{gather_path_matches, group_by_key, JsonLike, JsonObjectLike};
+
+// BorrowedValue
+impl<'a> JsonObjectLike<'a> for ObjectAsVec<'a> {
+    type Value = Value<'a>;
+    fn get_key(&'a self, key: &str) -> Option<&Value> {
+        self.get(key)
+    }
+}
+
+impl<'a> JsonLike<'a> for Value<'a> {
+    type JsonObject = ObjectAsVec<'a>;
+
+    fn null() -> Self {
+        Value::Null
+    }
+
+    fn as_array_ok(&'a self) -> Result<&'a Vec<Self>, &str> {
+        match self {
+            Value::Array(array) => Ok(array),
+            _ => Err("expected array"),
+        }
+    }
+
+    fn as_object_ok(&'a self) -> Result<&Self::JsonObject, &str> {
+        self.as_object().ok_or("expected object")
+    }
+
+    fn as_str_ok(&'a self) -> Result<&str, &str> {
+        self.as_str().ok_or("expected str")
+    }
+
+    fn as_i64_ok(&'a self) -> Result<i64, &str> {
+        self.as_i64().ok_or("expected i64")
+    }
+
+    fn as_u64_ok(&'a self) -> Result<u64, &str> {
+        self.as_u64().ok_or("expected u64")
+    }
+
+    fn as_f64_ok(&'a self) -> Result<f64, &str> {
+        self.as_f64().ok_or("expected f64")
+    }
+
+    fn as_bool_ok(&'a self) -> Result<bool, &str> {
+        self.as_bool().ok_or("expected bool")
+    }
+
+    fn as_null_ok(&'a self) -> Result<(), &str> {
+        if self.is_null() {
+            Ok(())
+        } else {
+            Err("expected null")
+        }
+    }
+
+    fn as_option_ok(&'a self) -> Result<Option<&Self>, &str> {
+        match self {
+            Value::Null => Ok(None),
+            _ => Ok(Some(self)),
+        }
+    }
+
+    fn get_path<T: AsRef<str>>(&'a self, path: &'a [T]) -> Option<&Self> {
+        let mut val = self;
+        for token in path {
+            val = match val {
+                Value::Array(arr) => {
+                    let index = token.as_ref().parse::<usize>().ok()?;
+                    arr.get(index)?
+                }
+                Value::Object(map) => map.get(token.as_ref())?,
+                _ => return None,
+            };
+        }
+        Some(val)
+    }
+
+    fn get_key(&'a self, _path: &'a str) -> Option<&Self> {
+        match self {
+            Value::Object(map) => map.get(_path),
+            _ => None,
+        }
+    }
+
+    fn group_by(&'a self, path: &'a [String]) -> std::collections::HashMap<String, Vec<&Self>> {
+        let src = gather_path_matches(self, path, vec![]);
+        group_by_key(src)
+    }
+}

src/core/json/graphql.rs

@@ -0,0 +1,112 @@
+use std::collections::HashMap;
+
+use async_graphql::Name;
+use async_graphql_value::ConstValue;
+use indexmap::IndexMap;
+
+use super::*;
+
+impl<'a, Value: JsonLike<'a> + Clone> JsonObjectLike<'a> for IndexMap<Name, Value> {
+    type Value = Value;
+    fn get_key(&'a self, key: &str) -> Option<&Self::Value> {
+        self.get(&Name::new(key))
+    }
+}
+
+impl<'a> JsonLike<'a> for ConstValue {
+    type JsonObject = IndexMap<Name, ConstValue>;
+
+    fn as_array_ok(&'a self) -> Result<&'a Vec<Self>, &str> {
+        match self {
+            ConstValue::List(seq) => Ok(seq),
+            _ => Err("array"),
+        }
+    }
+
+    fn as_str_ok(&self) -> Result<&str, &str> {
+        match self {
+            ConstValue::String(s) => Ok(s),
+            _ => Err("str"),
+        }
+    }
+
+    fn as_i64_ok(&self) -> Result<i64, &str> {
+        match self {
+            ConstValue::Number(n) => n.as_i64().ok_or("expected i64"),
+            _ => Err("i64"),
+        }
+    }
+
+    fn as_u64_ok(&self) -> Result<u64, &str> {
+        match self {
+            ConstValue::Number(n) => n.as_u64().ok_or("expected u64"),
+            _ => Err("u64"),
+        }
+    }
+
+    fn as_f64_ok(&self) -> Result<f64, &str> {
+        match self {
+            ConstValue::Number(n) => n.as_f64().ok_or("expected f64"),
+            _ => Err("f64"),
+        }
+    }
+
+    fn as_bool_ok(&self) -> Result<bool, &str> {
+        match self {
+            ConstValue::Boolean(b) => Ok(*b),
+            _ => Err("bool"),
+        }
+    }
+
+    fn as_null_ok(&self) -> Result<(), &str> {
+        match self {
+            ConstValue::Null => Ok(()),
+            _ => Err("null"),
+        }
+    }
+
+    fn as_option_ok(&self) -> Result<Option<&Self>, &str> {
+        match self {
+            ConstValue::Null => Ok(None),
+            _ => Ok(Some(self)),
+        }
+    }
+
+    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self> {
+        let mut val = self;
+        for token in path {
+            val = match val {
+                ConstValue::List(seq) => {
+                    let index = token.as_ref().parse::<usize>().ok()?;
+                    seq.get(index)?
+                }
+                ConstValue::Object(map) => map.get(token.as_ref())?,
+                _ => return None,
+            };
+        }
+        Some(val)
+    }
+
+    fn get_key(&self, path: &str) -> Option<&Self> {
+        match self {
+            ConstValue::Object(map) => map.get(&async_graphql::Name::new(path)),
+            _ => None,
+        }
+    }
+
+    fn group_by(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self>> {
+        let src = gather_path_matches(self, path, vec![]);
+        group_by_key(src)
+    }
+
+    fn null() -> Self {
+        Default::default()
+    }
+
+    fn as_object_ok(&'a self) -> Result<&Self::JsonObject, &str> {
+        match self {
+            ConstValue::Object(map) => Ok(map),
+            _ => Err("expected object"),
+        }
+    }
+}