chore: use tailcall value in place of ConstValue

src/core/blueprint/into_schema.rs

@@ -1,16 +1,16 @@
 use std::borrow::Cow;
 use std::sync::Arc;
 
-use async_graphql::dynamic::{self, FieldFuture, FieldValue, SchemaBuilder};
+use async_graphql::dynamic::{self, FieldFuture, SchemaBuilder};
 use async_graphql::ErrorExtensions;
-use async_graphql_value::ConstValue;
 use futures_util::TryFutureExt;
 use tracing::Instrument;
 
 use crate::core::blueprint::{Blueprint, Definition, Type};
 use crate::core::http::RequestContext;
 use crate::core::lambda::{Eval, EvaluationContext, ResolverContext};
 use crate::core::scalar::CUSTOM_SCALARS;
+use crate::core::value::Value;
 
 fn to_type_ref(type_of: &Type) -> dynamic::TypeRef {
     match type_of {
@@ -53,7 +53,7 @@ fn to_type(def: &Definition) -> dynamic::Type {
                             None => {
                                 let ctx: ResolverContext = ctx.into();
                                 let ctx = EvaluationContext::new(req_ctx, &ctx);
-                                FieldFuture::from_value(
+                                Value::into_field_future(
                                     ctx.path_value(&[field_name])
                                         .map(|a| a.into_owned().to_owned()),
                                 )
@@ -71,11 +71,7 @@ fn to_type(def: &Definition) -> dynamic::Type {
 
                                         let const_value =
                                             expr.eval(ctx).await.map_err(|err| err.extend())?;
-                                        let p = match const_value {
-                                            ConstValue::List(a) => Some(FieldValue::list(a)),
-                                            ConstValue::Null => FieldValue::NONE,
-                                            a => Some(FieldValue::from(a)),
-                                        };
+                                        let p = const_value.as_fieldValue();
                                         Ok(p)
                                     }
                                     .instrument(span)

src/core/config/headers.rs

@@ -45,7 +45,7 @@ impl Headers {
         self.cache_control.unwrap_or(false)
     }
     pub fn set_cookies(&self) -> bool {
-        self.set_cookies.unwrap_or_default()
+        self.set_cookies.unwrap_or(false)
     }
     pub fn get_cors(&self) -> Option<Cors> {
         self.cors.clone()

src/core/graphql/data_loader.rs

@@ -10,6 +10,7 @@ use crate::core::config::Batch;
 use crate::core::data_loader::{DataLoader, Loader};
 use crate::core::http::{DataLoaderRequest, Response};
 use crate::core::runtime::TargetRuntime;
+use crate::core::value::Value;
 
 pub struct GraphqlDataLoader {
     pub runtime: TargetRuntime,
@@ -33,7 +34,7 @@ impl GraphqlDataLoader {
 
 #[async_trait::async_trait]
 impl Loader<DataLoaderRequest> for GraphqlDataLoader {
-    type Value = Response<async_graphql::Value>;
+    type Value = Response<Value>;
     type Error = Arc<anyhow::Error>;
 
     #[allow(clippy::mutable_key_type)]
@@ -92,16 +93,14 @@ fn create_batched_request(dataloader_requests: &[DataLoaderRequest]) -> reqwest:
 
 #[allow(clippy::mutable_key_type)]
 fn extract_responses(
-    result: Result<Response<async_graphql::Value>, anyhow::Error>,
+    result: Result<Response<Value>, anyhow::Error>,
     keys: &[DataLoaderRequest],
-) -> HashMap<DataLoaderRequest, Response<async_graphql::Value>> {
+) -> HashMap<DataLoaderRequest, Response<Value>> {
     let mut hashmap = HashMap::new();
     if let Ok(res) = result {
-        if let async_graphql_value::ConstValue::List(values) = res.body {
+        if let Some(values) = Value::list(res.body) {
             for (i, request) in keys.iter().enumerate() {
-                let value = values
-                    .get(i)
-                    .unwrap_or(&async_graphql_value::ConstValue::Null);
+                let value = values.get(i).unwrap_or_default();
                 hashmap.insert(
                     request.clone(),
                     Response {

src/core/grpc/data_loader.rs

@@ -5,7 +5,6 @@ use std::time::Duration;
 use anyhow::Result;
 use async_graphql::async_trait;
 use async_graphql::futures_util::future::join_all;
-use async_graphql_value::ConstValue;
 
 use super::data_loader_request::DataLoaderRequest;
 use super::protobuf::ProtobufOperation;
@@ -17,6 +16,7 @@ use crate::core::grpc::request::create_grpc_request;
 use crate::core::http::Response;
 use crate::core::json::JsonLike;
 use crate::core::runtime::TargetRuntime;
+use crate::core::value::Value;
 
 #[derive(Clone)]
 pub struct GrpcDataLoader {
@@ -35,7 +35,7 @@ impl GrpcDataLoader {
     async fn load_dedupe_only(
         &self,
         keys: &[DataLoaderRequest],
-    ) -> anyhow::Result<HashMap<DataLoaderRequest, Response<async_graphql::Value>>> {
+    ) -> anyhow::Result<HashMap<DataLoaderRequest, Response<Value>>> {
         let results = keys.iter().map(|key| async {
             let result = match key.to_request() {
                 Ok(req) => execute_grpc_request(&self.runtime, &self.operation, req).await,
@@ -54,15 +54,14 @@ impl GrpcDataLoader {
         for (key, value) in results {
             hashmap.insert(key, value?);
         }
-
         Ok(hashmap)
     }
 
     async fn load_with_group_by(
         &self,
         group_by: &GroupBy,
         keys: &[DataLoaderRequest],
-    ) -> Result<HashMap<DataLoaderRequest, Response<async_graphql::Value>>> {
+    ) -> Result<HashMap<DataLoaderRequest, Response<Value>>> {
         let inputs = keys.iter().map(|key| key.template.body.as_str());
         let (multiple_body, grouped_keys) = self
             .operation
@@ -88,7 +87,7 @@ impl GrpcDataLoader {
                 response_body
                     .get(&id)
                     .and_then(|a| a.first().cloned().cloned())
-                    .unwrap_or(ConstValue::Null),
+                    .unwrap_or_default(),
             );
 
             result.insert(key.clone(), res);
@@ -100,7 +99,7 @@ impl GrpcDataLoader {
 
 #[async_trait::async_trait]
 impl Loader<DataLoaderRequest> for GrpcDataLoader {
-    type Value = Response<async_graphql::Value>;
+    type Value = Response<Value>;
     type Error = Arc<anyhow::Error>;
 
     async fn load(

src/core/grpc/request.rs

@@ -6,6 +6,7 @@ use url::Url;
 use super::protobuf::ProtobufOperation;
 use crate::core::http::Response;
 use crate::core::runtime::TargetRuntime;
+use crate::core::value::Value;
 
 pub static GRPC_STATUS: &str = "grpc-status";
 
@@ -21,7 +22,7 @@ pub async fn execute_grpc_request(
     runtime: &TargetRuntime,
     operation: &ProtobufOperation,
     request: Request,
-) -> Result<Response<async_graphql::Value>> {
+) -> Result<Response<Value>> {
     let response = runtime.http2_only.execute(request).await?;
 
     let grpc_status = response

src/core/http/cache.rs

@@ -1,8 +1,9 @@
+use crate::core::value::Value;
 use cache_control::CacheControl;
 
 use super::Response;
 
-pub fn cache_policy(res: &Response<async_graphql::Value>) -> Option<CacheControl> {
+pub fn cache_policy(res: &Response<Value>) -> Option<CacheControl> {
     let header = res.headers.get(hyper::header::CACHE_CONTROL)?;
     let value = header.to_str().ok()?;
 
@@ -20,7 +21,7 @@
     use crate::core::http::Response;
 
     pub fn max_age(res: &Response<async_graphql::Value>) -> Option<Duration> {
         match super::cache_policy(res) {
             Some(value) => value.max_age,
             None => None,
         }
@@ -42,7 +43,7 @@
     }
 
     pub fn cache_visibility(res: &Response<async_graphql::Value>) -> String {
         let cachability = super::cache_policy(res).and_then(|value| value.cachability);
 
         match cachability {
             Some(Cachability::Public) => "public".to_string(),

src/core/http/data_loader.rs

@@ -4,24 +4,24 @@ use std::time::Duration;
 
 use async_graphql::async_trait;
 use async_graphql::futures_util::future::join_all;
-use async_graphql_value::ConstValue;
 
 use crate::core::config::group_by::GroupBy;
 use crate::core::config::Batch;
 use crate::core::data_loader::{DataLoader, Loader};
 use crate::core::http::{DataLoaderRequest, Response};
 use crate::core::json::JsonLike;
 use crate::core::runtime::TargetRuntime;
+use crate::core::value::Value;
 
-fn get_body_value_single(body_value: &HashMap<String, Vec<&ConstValue>>, id: &str) -> ConstValue {
+fn get_body_value_single(body_value: &HashMap<String, Vec<&Value>>, id: &str) -> Value {
     body_value
         .get(id)
         .and_then(|a| a.first().cloned().cloned())
-        .unwrap_or(ConstValue::Null)
+        .unwrap_or_default()
 }
 
-fn get_body_value_list(body_value: &HashMap<String, Vec<&ConstValue>>, id: &str) -> ConstValue {
-    ConstValue::List(
+fn get_body_value_list(body_value: &HashMap<String, Vec<&Value>>, id: &str) -> Value {
+    Value::as_list(
         body_value
             .get(id)
             .unwrap_or(&Vec::new())
@@ -35,7 +35,7 @@ fn get_body_value_list(body_value: &HashMap<String, Vec<&ConstValue>>, id: &str)
 pub struct HttpDataLoader {
     pub runtime: TargetRuntime,
     pub group_by: Option<GroupBy>,
-    pub body: fn(&HashMap<String, Vec<&ConstValue>>, &str) -> ConstValue,
+    pub body: fn(&HashMap<String, Vec<&Value>>, &str) -> Value,
 }
 impl HttpDataLoader {
     pub fn new(runtime: TargetRuntime, group_by: Option<GroupBy>, is_list: bool) -> Self {
@@ -59,7 +59,7 @@ impl HttpDataLoader {
 
 #[async_trait::async_trait]
 impl Loader<DataLoaderRequest> for HttpDataLoader {
-    type Value = Response<async_graphql::Value>;
+    type Value = Response<Value>;
     type Error = Arc<anyhow::Error>;
 
     async fn load(
@@ -84,7 +84,7 @@ impl Loader<DataLoaderRequest> for HttpDataLoader {
                 .http
                 .execute(request)
                 .await?
-                .to_json::<ConstValue>()?;
+                .to_json::<Value>()?;
             #[allow(clippy::mutable_key_type)]
             let mut hashmap = HashMap::with_capacity(keys.len());
             let path = &group_by.path();

src/core/http/request_context.rs

@@ -2,7 +2,6 @@ use std::num::NonZeroU64;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
-use async_graphql_value::ConstValue;
 use cache_control::{Cachability, CacheControl};
 use derive_setters::Setters;
 use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
@@ -17,6 +16,7 @@ use crate::core::grpc::data_loader::GrpcDataLoader;
 use crate::core::http::{AppContext, DataLoaderRequest, HttpDataLoader};
 use crate::core::lambda::EvaluationError;
 use crate::core::runtime::TargetRuntime;
+use crate::core::value::Value;
 
 #[derive(Setters)]
 pub struct RequestContext {
@@ -34,7 +34,7 @@ pub struct RequestContext {
     pub min_max_age: Arc<Mutex<Option<i32>>>,
     pub cache_public: Arc<Mutex<Option<bool>>>,
     pub runtime: TargetRuntime,
-    pub cache: AsyncCache<u64, ConstValue, EvaluationError>,
+    pub cache: AsyncCache<u64, Value, EvaluationError>,
 }
 
 impl RequestContext {
@@ -134,15 +134,15 @@ impl RequestContext {
         }
     }
 
-    pub async fn cache_get(&self, key: &u64) -> anyhow::Result<Option<ConstValue>> {
+    pub async fn cache_get(&self, key: &u64) -> anyhow::Result<Option<Value>> {
         self.runtime.cache.get(key).await
     }
 
     #[allow(clippy::too_many_arguments)]
     pub async fn cache_insert(
         &self,
         key: u64,
-        value: ConstValue,
+        value: Value,
         ttl: NonZeroU64,
     ) -> anyhow::Result<()> {
         self.runtime.cache.set(key, value, ttl).await

src/core/http/response.rs

@@ -9,6 +9,7 @@ use tonic_types::Status as GrpcStatus;
 
 use crate::core::grpc::protobuf::ProtobufOperation;
 use crate::core::lambda::EvaluationError;
+use crate::core::value::Value;
 
 #[derive(Clone, Debug, Default, Setters)]
 pub struct Response<Body> {
@@ -27,6 +28,12 @@ pub trait FromValue {
     fn from_value(value: serde_json_borrow::Value) -> Self;
 }
 
+impl FromValue for Value {
+    fn from_value(value: serde_json_borrow::Value) -> Self {
+        ConstValue::from_value(value).into()
+    }
+}
+
 impl FromValue for ConstValue {
     fn from_value(value: serde_json_borrow::Value) -> Self {
         match value {
@@ -78,12 +85,9 @@ impl Response<Bytes> {
         Ok(Response { status: self.status, headers: self.headers, body })
     }
 
-    pub fn to_grpc_value(
-        self,
-        operation: &ProtobufOperation,
-    ) -> Result<Response<async_graphql::Value>> {
+    pub fn to_grpc_value(self, operation: &ProtobufOperation) -> Result<Response<Value>> {
         let mut resp = Response::default();
-        let body = operation.convert_output::<async_graphql::Value>(&self.body)?;
+        let body = operation.convert_output::<Value>(&self.body)?;
         resp.body = body;
         resp.status = self.status;
         resp.headers = self.headers;

src/core/lambda/cache.rs

@@ -1,9 +1,9 @@
 use core::future::Future;
 use std::num::NonZeroU64;
 use std::ops::Deref;
 use std::pin::Pin;
 
-use async_graphql_value::ConstValue;
+use crate::core::value::Value;
 
 use super::{Eval, EvaluationContext, EvaluationError, Expression, ResolverContextLike};
 
@@ -37,7 +37,7 @@
     fn eval<'a, Ctx: ResolverContextLike<'a> + Sync + Send>(
         &'a self,
         ctx: EvaluationContext<'a, Ctx>,
-    ) -> Pin<Box<dyn Future<Output = Result<ConstValue, EvaluationError>> + 'a + Send>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Value, EvaluationError>> + 'a + Send>> {
         Box::pin(async move {
             if let Expression::IO(io) = self.expr.deref() {
                 let key = io.cache_key(&ctx);

src/core/lambda/eval.rs

@@ -1,9 +1,10 @@
+use crate::core::value::Value;
 use core::future::Future;
 use std::pin::Pin;
 
 use super::{EvaluationContext, EvaluationError, ResolverContextLike};
 
-pub trait Eval<Output = async_graphql::Value>
+pub trait Eval<Output = Value>
 where
     Self: Send + Sync,
 {

src/core/lambda/evaluation_context.rs

@@ -2,11 +2,12 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
-use async_graphql::{SelectionField, ServerError, Value};
+use async_graphql::{SelectionField, ServerError};
 use reqwest::header::HeaderMap;
 
 use super::{GraphQLOperationContext, ResolverContextLike};
 use crate::core::http::RequestContext;
+use crate::core::value::Value;
 
 // TODO: rename to ResolverContext
 #[derive(Clone)]
@@ -60,9 +61,9 @@
         } else if path.is_empty() {
             self.graphql_ctx
                 .args()
-                .map(|a| Cow::Owned(Value::Object(a.clone())))
+                .map(|a| Cow::Owned(Value::as_object(a)))
         } else {
-            let arg = self.graphql_ctx.args()?.get(path[0].as_ref())?;
+            let arg = self.graphql_ctx.args()?.get(path[0].as_ref())?.clone();
             get_path_value(arg, &path[1..]).map(Cow::Borrowed)
         }
     }
@@ -168,14 +169,8 @@
     let mut value = Some(input);
     for name in path {
         match value {
-            Some(Value::Object(map)) => {
-                value = map.get(name.as_ref());
-            }
-
-            Some(Value::List(list)) => {
-                value = list.get(name.as_ref().parse::<usize>().ok()?);
-            }
-            _ => return None,
+            Some(inp) => value = inp.get(name.as_ref()),
+            None => return None,
         }
     }
 
@@ -203,9 +198,9 @@
         let async_value = Value::from_json(json).unwrap();
 
         let path = vec!["a".to_string(), "b".to_string(), "c".to_string()];
         let result = get_path_value(&async_value, &path);
         assert!(result.is_some());
         assert_eq!(result.unwrap(), &Value::String("d".to_string()));
     }
 
     #[test]
@@ -220,7 +215,7 @@
         let async_value = Value::from_json(json).unwrap();
 
         let path = vec!["a".to_string(), "b".to_string(), "c".to_string()];
         let result = get_path_value(&async_value, &path);
         assert!(result.is_none());
     }
 
@@ -236,8 +231,8 @@
         let async_value = Value::from_json(json).unwrap();
 
         let path = vec!["a".to_string(), "0".to_string(), "b".to_string()];
         let result = get_path_value(&async_value, &path);
         assert!(result.is_some());
         assert_eq!(result.unwrap(), &Value::String("c".to_string()));
     }
 }