chore: impl JsonObjectLike (tailcallhq#2385)

Co-authored-by: Tushar Mathur <tusharmath@gmail.com>

src/core/jit/exec.rs

@@ -22,7 +22,7 @@ pub struct Executor<Synth, IRExec> {
 
 impl<Input, Output, Error, Synth, Exec> Executor<Synth, Exec>
 where
-    Output: JsonLike<Output = Output> + Debug,
+    Output: JsonLike<Json = Output> + Debug,
     Synth: Synthesizer<Value = Result<Output, Error>>,
     Exec: IRExecutor<Input = Input, Output = Output, Error = Error>,
 {
@@ -55,7 +55,7 @@ struct ExecutorInner<'a, Input, Output, Error, Exec> {
 
 impl<'a, Input, Output, Error, Exec> ExecutorInner<'a, Input, Output, Error, Exec>
 where
-    Output: JsonLike<Output = Output> + Debug,
+    Output: JsonLike<Json = Output> + Debug,
     Exec: IRExecutor<Input = Input, Output = Output, Error = Error>,
 {
     fn new(

src/core/json/json_like.rs

@@ -2,26 +2,38 @@ use std::collections::HashMap;
 
 use async_graphql_value::ConstValue;
 
+use crate::core::json::json_object_like::JsonObjectLike;
+
 pub trait JsonLike {
-    type Output;
-    fn as_array_ok(&self) -> Result<&Vec<Self::Output>, &str>;
+    type Json;
+    type JsonObject: JsonObjectLike;
+
+    // Constructors
+    fn default() -> Self;
+    fn new_array(arr: Vec<Self::Json>) -> Self;
+    fn new(value: &Self::Json) -> &Self;
+
+    // Operators
+    fn as_array_ok(&self) -> Result<&Vec<Self::Json>, &str>;
+    fn as_object_ok(&self) -> Result<&Self::JsonObject, &str>;
     fn as_str_ok(&self) -> Result<&str, &str>;
     fn as_string_ok(&self) -> Result<&String, &str>;
     fn as_i64_ok(&self) -> Result<i64, &str>;
     fn as_u64_ok(&self) -> Result<u64, &str>;
     fn as_f64_ok(&self) -> Result<f64, &str>;
     fn as_bool_ok(&self) -> Result<bool, &str>;
     fn as_null_ok(&self) -> Result<(), &str>;
-    fn as_option_ok(&self) -> Result<Option<&Self::Output>, &str>;
-    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Output>;
-    fn get_key(&self, path: &str) -> Option<&Self::Output>;
-    fn new(value: &Self::Output) -> &Self;
-    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Output>>;
+    fn as_option_ok(&self) -> Result<Option<&Self::Json>, &str>;
+    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Json>;
+    fn get_key(&self, path: &str) -> Option<&Self::Json>;
+    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Json>>;
 }
 
 impl JsonLike for serde_json::Value {
-    type Output = serde_json::Value;
-    fn as_array_ok(&self) -> Result<&Vec<Self::Output>, &str> {
+    type Json = serde_json::Value;
+    type JsonObject = serde_json::Map<String, serde_json::Value>;
+
+    fn as_array_ok(&self) -> Result<&Vec<Self::Json>, &str> {
         self.as_array().ok_or("expected array")
     }
     fn as_str_ok(&self) -> Result<&str, &str> {
@@ -43,14 +55,14 @@ impl JsonLike for serde_json::Value {
         self.as_null().ok_or("expected null")
     }
 
-    fn as_option_ok(&self) -> Result<Option<&Self::Output>, &str> {
+    fn as_option_ok(&self) -> Result<Option<&Self::Json>, &str> {
         match self {
             serde_json::Value::Null => Ok(None),
             _ => Ok(Some(self)),
         }
     }
 
-    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Output> {
+    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Json> {
         let mut val = self;
         for token in path {
             val = match val {
@@ -65,11 +77,11 @@ impl JsonLike for serde_json::Value {
         Some(val)
     }
 
-    fn new(value: &Self::Output) -> &Self {
+    fn new(value: &Self::Json) -> &Self {
         value
     }
 
-    fn get_key(&self, path: &str) -> Option<&Self::Output> {
+    fn get_key(&self, path: &str) -> Option<&Self::Json> {
         match self {
             serde_json::Value::Object(map) => map.get(path),
             _ => None,
@@ -83,16 +95,32 @@ impl JsonLike for serde_json::Value {
         }
     }
 
-    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Output>> {
+    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Json>> {
         let src = gather_path_matches(self, path, vec![]);
         group_by_key(src)
     }
+
+    fn default() -> Self {
+        Self::Null
+    }
+
+    fn new_array(arr: Vec<Self::Json>) -> Self {
+        Self::Array(arr)
+    }
+
+    fn as_object_ok(&self) -> Result<&Self::JsonObject, &str> {
+        match self {
+            serde_json::Value::Object(map) => Ok(map),
+            _ => Err("expected object"),
+        }
+    }
 }
 
 impl JsonLike for async_graphql::Value {
-    type Output = async_graphql::Value;
+    type Json = async_graphql::Value;
+    type JsonObject = indexmap::IndexMap<async_graphql::Name, async_graphql::Value>;
 
-    fn as_array_ok(&self) -> Result<&Vec<Self::Output>, &str> {
+    fn as_array_ok(&self) -> Result<&Vec<Self::Json>, &str> {
         match self {
             ConstValue::List(seq) => Ok(seq),
             _ => Err("array"),
@@ -141,14 +169,14 @@ impl JsonLike for async_graphql::Value {
         }
     }
 
-    fn as_option_ok(&self) -> Result<Option<&Self::Output>, &str> {
+    fn as_option_ok(&self) -> Result<Option<&Self::Json>, &str> {
         match self {
             ConstValue::Null => Ok(None),
             _ => Ok(Some(self)),
         }
     }
 
-    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Output> {
+    fn get_path<T: AsRef<str>>(&self, path: &[T]) -> Option<&Self::Json> {
         let mut val = self;
         for token in path {
             val = match val {
@@ -163,11 +191,11 @@ impl JsonLike for async_graphql::Value {
         Some(val)
     }
 
-    fn new(value: &Self::Output) -> &Self {
+    fn new(value: &Self::Json) -> &Self {
         value
     }
 
-    fn get_key(&self, path: &str) -> Option<&Self::Output> {
+    fn get_key(&self, path: &str) -> Option<&Self::Json> {
         match self {
             ConstValue::Object(map) => map.get(&async_graphql::Name::new(path)),
             _ => None,
@@ -180,10 +208,25 @@ impl JsonLike for async_graphql::Value {
         }
     }
 
-    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Output>> {
+    fn group_by<'a>(&'a self, path: &'a [String]) -> HashMap<String, Vec<&'a Self::Json>> {
         let src = gather_path_matches(self, path, vec![]);
         group_by_key(src)
     }
+
+    fn default() -> Self {
+        Default::default()
+    }
+
+    fn new_array(arr: Vec<Self::Json>) -> Self {
+        ConstValue::List(arr)
+    }
+
+    fn as_object_ok(&self) -> Result<&Self::JsonObject, &str> {
+        match self {
+            ConstValue::Object(map) => Ok(map),
+            _ => Err("expected object"),
+        }
+    }
 }
 
 // Highly micro-optimized and benchmarked version of get_path_all

src/core/json/json_object_like.rs

@@ -0,0 +1,26 @@
+use indexmap::IndexMap;
+
+use crate::core::json::JsonLike;
+
+pub trait JsonObjectLike {
+    type Value<'a>: JsonLike
+    where
+        Self: 'a;
+    fn get<'a>(&'a self, key: &'a str) -> Option<&Self::Value<'a>>;
+}
+
+impl JsonObjectLike for serde_json::Map<String, serde_json::Value> {
+    type Value<'a> = serde_json::Value;
+
+    fn get<'a>(&'a self, key: &'a str) -> Option<&Self::Value<'a>> {
+        self.get(key)
+    }
+}
+
+impl<V: JsonLike + Clone> JsonObjectLike for IndexMap<async_graphql_value::Name, V> {
+    type Value<'a> = V where V: 'a;
+
+    fn get<'a>(&'a self, key: &'a str) -> Option<&Self::Value<'a>> {
+        self.get(&async_graphql_value::Name::new(key))
+    }
+}

src/core/json/mod.rs

@@ -1,4 +1,7 @@
 mod json_like;
+mod json_object_like;
 mod json_schema;
+
 pub use json_like::*;
+pub use json_object_like::*;
 pub use json_schema::*;