yume/juniper
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename execute -> execute_sync, execute_async -> execute ()

Browse source
This commit is contained in:
Christian Legnitto 2020-03-09 22:40:26 -07:00 • committed by GitHub
parent 1411969c37
commit e9b8aa2c38
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
45 changed files with 353 additions and 358 deletions

6
benches/bench.rs
View file

@ -3,7 +3,7 @@ extern crate juniper;
use bencher::Bencher;
use juniper::{execute, RootNode, EmptyMutation, Variables};
use juniper::{execute_sync, RootNode, EmptyMutation, Variables};
use juniper::tests::model::Database;
fn query_type_name(b: &mut Bencher) {
@ -19,7 +19,7 @@ fn query_type_name(b: &mut Bencher) {
}
}"#;
b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
b.iter(|| execute_sync(doc, None, &schema, &Variables::new(), &database));
}
fn introspection_query(b: &mut Bencher) {
@ -120,7 +120,7 @@ fn introspection_query(b: &mut Bencher) {
}
"#;
b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
b.iter(|| execute_sync(doc, None, &schema, &Variables::new(), &database));
}
benchmark_group!(queries, query_type_name, introspection_query);

2
docs/book/content/advanced/dataloaders.md
View file

@ -172,7 +172,7 @@ pub async fn graphql(
let ctx = Context::new(cult_loader);
// Execute
let future_execute = data.execute_async(&st, &ctx);
let future_execute = data.execute(&st, &ctx);
let res = rt.run_until(future_execute);
let json = serde_json::to_string(&res).map_err(error::ErrorInternalServerError)?;

2
docs/book/content/quickstart.md
View file

@ -175,7 +175,7 @@ fn main() {
let ctx = Ctx(Episode::NewHope);
// Run the executor.
let (res, _errors) = juniper::execute(
let (res, _errors) = juniper::execute_sync(
"query { favoriteEpisode }",
None,
&Schema::new(Query, EmptyMutation::new()),

4
integration_tests/async_await/src/main.rs
View file

@ -87,7 +87,7 @@ async fn async_simple() {
"#;
let vars = Default::default();
let (res, errs) = juniper::execute_async(doc, None, &schema, &vars, &())
let (res, errs) = juniper::execute(doc, None, &schema, &vars, &())
.await
.unwrap();
@ -130,7 +130,7 @@ async fn async_field_validation_error() {
"#;
let vars = Default::default();
let result = juniper::execute_async(doc, None, &schema, &vars, &()).await;
let result = juniper::execute(doc, None, &schema, &vars, &()).await;
assert!(result.is_err());
let error = result.err().unwrap();

3
integration_tests/juniper_tests/Cargo.toml
View file

@ -10,4 +10,5 @@ futures = "0.3.1"
[dev-dependencies]
serde_json = { version = "1" }
fnv = "1.0.3"
fnv = "1.0.3"
tokio = { version = "0.2", features = ["rt-core", "time", "macros"] }

35
integration_tests/juniper_tests/src/codegen/derive_object.rs
View file

@ -170,8 +170,8 @@ fn test_doc_comment_override() {
);
}
#[test]
fn test_derived_object() {
#[tokio::test]
async fn test_derived_object() {
assert_eq!(
<Obj as GraphQLType<DefaultScalarValue>>::name(&()),
Some("MyObj")
@ -195,7 +195,7 @@ fn test_derived_object() {
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
assert_eq!(
execute(doc, None, &schema, &Variables::new(), &()),
execute(doc, None, &schema, &Variables::new(), &()).await,
Ok((
Value::object(
vec![(
@ -217,9 +217,9 @@ fn test_derived_object() {
);
}
#[test]
#[tokio::test]
#[should_panic]
fn test_cannot_query_skipped_field() {
async fn test_cannot_query_skipped_field() {
let doc = r#"
{
skippedFieldObj {
@ -227,11 +227,13 @@ fn test_cannot_query_skipped_field() {
}
}"#;
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
execute(doc, None, &schema, &Variables::new(), &()).unwrap();
execute(doc, None, &schema, &Variables::new(), &())
.await
.unwrap();
}
#[test]
fn test_skipped_field_siblings_unaffected() {
#[tokio::test]
async fn test_skipped_field_siblings_unaffected() {
let doc = r#"
{
skippedFieldObj {
@ -239,11 +241,13 @@ fn test_skipped_field_siblings_unaffected() {
}
}"#;
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
execute(doc, None, &schema, &Variables::new(), &()).unwrap();
execute(doc, None, &schema, &Variables::new(), &())
.await
.unwrap();
}
#[test]
fn test_derived_object_nested() {
#[tokio::test]
async fn test_derived_object_nested() {
let doc = r#"
{
nested {
@ -257,7 +261,7 @@ fn test_derived_object_nested() {
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
assert_eq!(
execute(doc, None, &schema, &Variables::new(), &()),
execute(doc, None, &schema, &Variables::new(), &()).await,
Ok((
Value::object(
vec![(
@ -329,14 +333,15 @@ fn check_descriptions(
}
#[cfg(test)]
fn run_type_info_query<F>(doc: &str, f: F)
async fn run_type_info_query<F>(doc: &str, f: F)
where
F: Fn((&Object<DefaultScalarValue>, &Vec<Value>)) -> (),
{
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
let (result, errs) =
execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
let (result, errs) = execute(doc, None, &schema, &Variables::new(), &())
.await
.expect("Execution failed");
assert_eq!(errs, []);

19
integration_tests/juniper_tests/src/codegen/derive_object_with_raw_idents.rs
View file

@ -25,8 +25,8 @@ struct MyInputType {
r#trait: String,
}
#[test]
fn supports_raw_idents_in_types_and_args() {
#[tokio::test]
async fn supports_raw_idents_in_types_and_args() {
let doc = r#"
{
__type(name: "Query") {
@ -40,7 +40,7 @@ fn supports_raw_idents_in_types_and_args() {
}
"#;
let value = run_type_info_query(&doc);
let value = run_type_info_query(&doc).await;
assert_eq!(
value,
@ -63,8 +63,8 @@ fn supports_raw_idents_in_types_and_args() {
);
}
#[test]
fn supports_raw_idents_in_fields_of_input_types() {
#[tokio::test]
async fn supports_raw_idents_in_fields_of_input_types() {
let doc = r#"
{
__type(name: "MyInputType") {
@ -75,7 +75,7 @@ fn supports_raw_idents_in_fields_of_input_types() {
}
"#;
let value = run_type_info_query(&doc);
let value = run_type_info_query(&doc).await;
assert_eq!(
value,
@ -94,11 +94,12 @@ fn supports_raw_idents_in_fields_of_input_types() {
}
#[cfg(test)]
fn run_type_info_query(doc: &str) -> Value {
async fn run_type_info_query(doc: &str) -> Value {
let schema = RootNode::new(Query, EmptyMutation::<()>::new());
let (result, errs) =
execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
let (result, errs) = execute(doc, None, &schema, &Variables::new(), &())
.await
.expect("Execution failed");
assert_eq!(errs, []);

2
integration_tests/juniper_tests/src/codegen/mod.rs
View file

@ -1,5 +1,3 @@
mod util;
mod derive_enum;
mod derive_input_object;
mod derive_object;

54
integration_tests/juniper_tests/src/codegen/util.rs
View file

@ -1,54 +0,0 @@
use juniper::{DefaultScalarValue, GraphQLType, RootNode, Value, Variables};
use std::default::Default;
pub fn run_query<Query, Mutation, Context>(query: &str) -> Value
where
Query: GraphQLType<DefaultScalarValue, TypeInfo = (), Context = Context> + Default,
Mutation: GraphQLType<DefaultScalarValue, TypeInfo = (), Context = Context> + Default,
Context: Default,
{
let schema = RootNode::new(Query::default(), Mutation::default());
let (result, errs) =
juniper::execute(query, None, &schema, &Variables::new(), &Context::default())
.expect("Execution failed");
assert_eq!(errs, []);
result
}
pub fn run_info_query<Query, Mutation, Context>(type_name: &str) -> Value
where
Query: GraphQLType<DefaultScalarValue, TypeInfo = (), Context = Context> + Default,
Mutation: GraphQLType<DefaultScalarValue, TypeInfo = (), Context = Context> + Default,
Context: Default,
{
let query = format!(
r#"
{{
__type(name: "{}") {{
name,
description,
fields {{
name
description
args {{
name
description
type {{
name
}}
}}
}}
}}
}}
"#,
type_name
);
let result = run_query::<Query, Mutation, Context>(&query);
result
.as_object_value()
.expect("Result is not an object")
.get_field_value("__type")
.expect("__type field missing")
.clone()
}

42
integration_tests/juniper_tests/src/custom_scalar.rs
View file

@ -2,14 +2,11 @@ extern crate serde_json;
use futures;
#[cfg(test)]
use juniper::parser::Spanning;
#[cfg(test)]
use juniper::{execute, EmptyMutation, Object, RootNode, Variables};
use juniper::{
parser::{ParseError, ScalarToken, Token},
execute,
parser::{ParseError, ScalarToken, Spanning, Token},
serde::de,
InputValue, ParseScalarResult, ScalarValue, Value,
EmptyMutation, InputValue, Object, ParseScalarResult, RootNode, ScalarValue, Value, Variables,
};
use std::fmt;
@ -175,14 +172,15 @@ impl TestType {
}
}
#[cfg(test)]
fn run_variable_query<F>(query: &str, vars: Variables<MyScalarValue>, f: F)
async fn run_variable_query<F>(query: &str, vars: Variables<MyScalarValue>, f: F)
where
F: Fn(&Object<MyScalarValue>) -> (),
{
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let (result, errs) = execute(query, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) = execute(query, None, &schema, &vars, &())
.await
.expect("Execution failed");
assert_eq!(errs, []);
@ -193,26 +191,26 @@ where
f(obj);
}
#[cfg(test)]
fn run_query<F>(query: &str, f: F)
async fn run_query<F>(query: &str, f: F)
where
F: Fn(&Object<MyScalarValue>) -> (),
{
run_variable_query(query, Variables::new(), f);
run_variable_query(query, Variables::new(), f).await;
}
#[test]
fn querying_long() {
#[tokio::test]
async fn querying_long() {
run_query("{ longField }", |result| {
assert_eq!(
result.get_field_value("longField"),
Some(&Value::scalar((::std::i32::MAX as i64) + 1))
);
});
})
.await;
}
#[test]
fn querying_long_arg() {
#[tokio::test]
async fn querying_long_arg() {
run_query(
&format!(
"{{ longWithArg(longArg: {}) }}",
@ -224,11 +222,12 @@ fn querying_long_arg() {
Some(&Value::scalar((::std::i32::MAX as i64) + 3))
);
},
);
)
.await;
}
#[test]
fn querying_long_variable() {
#[tokio::test]
async fn querying_long_variable() {
run_variable_query(
"query q($test: Long!){ longWithArg(longArg: $test) }",
vec![(
@ -243,7 +242,8 @@ fn querying_long_variable() {
Some(&Value::scalar((::std::i32::MAX as i64) + 42))
);
},
);
)
.await;
}
#[test]

20
integration_tests/juniper_tests/src/issue_371.rs
View file

@ -50,8 +50,8 @@ impl Country {
type Schema = juniper::RootNode<'static, Query, EmptyMutation<Context>>;
#[test]
fn users() {
#[tokio::test]
async fn users() {
let ctx = Context;
let query = r#"{ users { id } }"#;
@ -63,13 +63,14 @@ fn users() {
&juniper::Variables::new(),
&ctx,
)
.await
.unwrap();
assert_eq!(errors.len(), 0);
}
#[test]
fn countries() {
#[tokio::test]
async fn countries() {
let ctx = Context;
let query = r#"{ countries { id } }"#;
@ -81,13 +82,14 @@ fn countries() {
&juniper::Variables::new(),
&ctx,
)
.await
.unwrap();
assert_eq!(errors.len(), 0);
}
#[test]
fn both() {
#[tokio::test]
async fn both() {
let ctx = Context;
let query = r#"
@ -104,13 +106,14 @@ fn both() {
&juniper::Variables::new(),
&ctx,
)
.await
.unwrap();
assert_eq!(errors.len(), 0);
}
#[test]
fn both_in_different_order() {
#[tokio::test]
async fn both_in_different_order() {
let ctx = Context;
let query = r#"
@ -127,6 +130,7 @@ fn both_in_different_order() {
&juniper::Variables::new(),
&ctx,
)
.await
.unwrap();
assert_eq!(errors.len(), 0);

5
integration_tests/juniper_tests/src/issue_398.rs
View file

@ -44,8 +44,8 @@ impl Country {
type Schema = juniper::RootNode<'static, Query, EmptyMutation<()>>;
#[test]
fn test_lookahead_from_fragment_with_nested_type() {
#[tokio::test]
async fn test_lookahead_from_fragment_with_nested_type() {
let _ = juniper::execute(
r#"
query Query {
@ -65,5 +65,6 @@ fn test_lookahead_from_fragment_with_nested_type() {
&Variables::new(),
&(),
)
.await
.unwrap();
}

6
juniper/benches/bench.rs
View file

@ -4,7 +4,7 @@ extern crate juniper;
use bencher::Bencher;
use juniper::{execute, tests::model::Database, EmptyMutation, RootNode, Variables};
use juniper::{execute_sync, tests::model::Database, EmptyMutation, RootNode, Variables};
fn query_type_name(b: &mut Bencher) {
let database = Database::new();
@ -19,7 +19,7 @@ fn query_type_name(b: &mut Bencher) {
}
}"#;
b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
b.iter(|| execute_sync(doc, None, &schema, &Variables::new(), &database));
}
fn introspection_query(b: &mut Bencher) {
@ -120,7 +120,7 @@ fn introspection_query(b: &mut Bencher) {
}
"#;
b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
b.iter(|| execute_sync(doc, None, &schema, &Variables::new(), &database));
}
benchmark_group!(queries, query_type_name, introspection_query);

2
juniper/src/executor_tests/async_await/mod.rs
View file

@ -86,7 +86,7 @@ async fn async_simple() {
"#;
let vars = Default::default();
let (res, errs) = crate::execute_async(doc, None, &schema, &vars, &())
let (res, errs) = crate::execute(doc, None, &schema, &vars, &())
.await
.unwrap();

151
juniper/src/executor_tests/directives.rs
View file

@ -18,14 +18,15 @@ impl TestType {
}
}
fn run_variable_query<F>(query: &str, vars: Variables<DefaultScalarValue>, f: F)
async fn run_variable_query<F>(query: &str, vars: Variables<DefaultScalarValue>, f: F)
where
F: Fn(&Object<DefaultScalarValue>) -> (),
{
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(query, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) = crate::execute(query, None, &schema, &vars, &())
.await
.expect("Execution failed");
assert_eq!(errs, []);
@ -36,187 +37,207 @@ where
f(obj);
}
fn run_query<F>(query: &str, f: F)
async fn run_query<F>(query: &str, f: F)
where
F: Fn(&Object<DefaultScalarValue>) -> (),
{
run_variable_query(query, Variables::new(), f);
run_variable_query(query, Variables::new(), f).await;
}
#[test]
fn scalar_include_true() {
#[tokio::test]
async fn scalar_include_true() {
run_query("{ a, b @include(if: true) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn scalar_include_false() {
#[tokio::test]
async fn scalar_include_false() {
run_query("{ a, b @include(if: false) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn scalar_skip_false() {
#[tokio::test]
async fn scalar_skip_false() {
run_query("{ a, b @skip(if: false) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn scalar_skip_true() {
#[tokio::test]
async fn scalar_skip_true() {
run_query("{ a, b @skip(if: true) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn fragment_spread_include_true() {
#[tokio::test]
async fn fragment_spread_include_true() {
run_query(
"{ a, ...Frag @include(if: true) } fragment Frag on TestType { b }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
},
);
)
.await;
}
#[test]
fn fragment_spread_include_false() {
#[tokio::test]
async fn fragment_spread_include_false() {
run_query(
"{ a, ...Frag @include(if: false) } fragment Frag on TestType { b }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
},
);
)
.await;
}
#[test]
fn fragment_spread_skip_false() {
#[tokio::test]
async fn fragment_spread_skip_false() {
run_query(
"{ a, ...Frag @skip(if: false) } fragment Frag on TestType { b }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
},
);
)
.await;
}
#[test]
fn fragment_spread_skip_true() {
#[tokio::test]
async fn fragment_spread_skip_true() {
run_query(
"{ a, ...Frag @skip(if: true) } fragment Frag on TestType { b }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
},
);
)
.await;
}
#[test]
fn inline_fragment_include_true() {
#[tokio::test]
async fn inline_fragment_include_true() {
run_query(
"{ a, ... on TestType @include(if: true) { b } }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
},
);
)
.await;
}
#[test]
fn inline_fragment_include_false() {
#[tokio::test]
async fn inline_fragment_include_false() {
run_query(
"{ a, ... on TestType @include(if: false) { b } }",
|result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
},
);
)
.await;
}
#[test]
fn inline_fragment_skip_false() {
#[tokio::test]
async fn inline_fragment_skip_false() {
run_query("{ a, ... on TestType @skip(if: false) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn inline_fragment_skip_true() {
#[tokio::test]
async fn inline_fragment_skip_true() {
run_query("{ a, ... on TestType @skip(if: true) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn anonymous_inline_fragment_include_true() {
#[tokio::test]
async fn anonymous_inline_fragment_include_true() {
run_query("{ a, ... @include(if: true) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn anonymous_inline_fragment_include_false() {
#[tokio::test]
async fn anonymous_inline_fragment_include_false() {
run_query("{ a, ... @include(if: false) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn anonymous_inline_fragment_skip_false() {
#[tokio::test]
async fn anonymous_inline_fragment_skip_false() {
run_query("{ a, ... @skip(if: false) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn anonymous_inline_fragment_skip_true() {
#[tokio::test]
async fn anonymous_inline_fragment_skip_true() {
run_query("{ a, ... @skip(if: true) { b } }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn scalar_include_true_skip_true() {
#[tokio::test]
async fn scalar_include_true_skip_true() {
run_query("{ a, b @include(if: true) @skip(if: true) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn scalar_include_true_skip_false() {
#[tokio::test]
async fn scalar_include_true_skip_false() {
run_query("{ a, b @include(if: true) @skip(if: false) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), Some(&Value::scalar("b")));
});
})
.await;
}
#[test]
fn scalar_include_false_skip_true() {
#[tokio::test]
async fn scalar_include_false_skip_true() {
run_query("{ a, b @include(if: false) @skip(if: true) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}
#[test]
fn scalar_include_false_skip_false() {
#[tokio::test]
async fn scalar_include_false_skip_false() {
run_query("{ a, b @include(if: false) @skip(if: false) }", |result| {
assert_eq!(result.get_field_value("a"), Some(&Value::scalar("a")));
assert_eq!(result.get_field_value("b"), None);
});
})
.await;
}

56
juniper/src/executor_tests/enums.rs
View file

@ -30,14 +30,15 @@ impl TestType {
}
}
fn run_variable_query<F>(query: &str, vars: Variables<DefaultScalarValue>, f: F)
async fn run_variable_query<F>(query: &str, vars: Variables<DefaultScalarValue>, f: F)
where
F: Fn(&Object<DefaultScalarValue>) -> (),
{
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(query, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) = crate::execute(query, None, &schema, &vars, &())
.await
.expect("Execution failed");
assert_eq!(errs, []);
@ -48,41 +49,45 @@ where
f(obj);
}
fn run_query<F>(query: &str, f: F)
async fn run_query<F>(query: &str, f: F)
where
F: Fn(&Object<DefaultScalarValue>) -> (),
{
run_variable_query(query, Variables::new(), f);
run_variable_query(query, Variables::new(), f).await;
}
#[test]
fn accepts_enum_literal() {
#[tokio::test]
async fn accepts_enum_literal() {
run_query("{ toString(color: RED) }", |result| {
assert_eq!(
result.get_field_value("toString"),
Some(&Value::scalar("Color::Red"))
);
});
})
.await;
}
#[test]
fn serializes_as_output() {
#[tokio::test]
async fn serializes_as_output() {
run_query("{ aColor }", |result| {
assert_eq!(
result.get_field_value("aColor"),
Some(&Value::scalar("RED"))
);
});
})
.await;
}
#[test]
fn does_not_accept_string_literals() {
#[tokio::test]
async fn does_not_accept_string_literals() {
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let query = r#"{ toString(color: "RED") }"#;
let vars = vec![].into_iter().collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute(query, None, &schema, &vars, &())
.await
.unwrap_err();
assert_eq!(
error,
@ -93,8 +98,8 @@ fn does_not_accept_string_literals() {
);
}
#[test]
fn accepts_strings_in_variables() {
#[tokio::test]
async fn accepts_strings_in_variables() {
run_variable_query(
"query q($color: Color!) { toString(color: $color) }",
vec![("color".to_owned(), InputValue::scalar("RED"))]
@ -106,11 +111,12 @@ fn accepts_strings_in_variables() {
Some(&Value::scalar("Color::Red"))
);
},
);
)
.await;
}
#[test]
fn does_not_accept_incorrect_enum_name_in_variables() {
#[tokio::test]
async fn does_not_accept_incorrect_enum_name_in_variables() {
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let query = r#"query q($color: Color!) { toString(color: $color) }"#;
@ -118,7 +124,9 @@ fn does_not_accept_incorrect_enum_name_in_variables() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute(query, None, &schema, &vars, &())
.await
.unwrap_err();
assert_eq!(
error,
@ -129,8 +137,8 @@ fn does_not_accept_incorrect_enum_name_in_variables() {
);
}
#[test]
fn does_not_accept_incorrect_type_in_variables() {
#[tokio::test]
async fn does_not_accept_incorrect_type_in_variables() {
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let query = r#"query q($color: Color!) { toString(color: $color) }"#;
@ -138,7 +146,9 @@ fn does_not_accept_incorrect_type_in_variables() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute(query, None, &schema, &vars, &())
.await
.unwrap_err();
assert_eq!(
error,

45
juniper/src/executor_tests/executor.rs
View file

@ -88,7 +88,7 @@ mod field_execution {
.collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -192,7 +192,7 @@ mod merge_parallel_fragments {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -310,7 +310,7 @@ mod merge_parallel_inline_fragments {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -406,7 +406,7 @@ mod threads_context_correctly {
let vars = vec![].into_iter().collect();
let (result, errs) = crate::execute(
let (result, errs) = crate::execute_sync(
doc,
None,
&schema,
@ -522,7 +522,7 @@ mod dynamic_context_switching {
};
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &ctx).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &ctx).expect("Execution failed");
assert_eq!(errs, []);
@ -579,7 +579,7 @@ mod dynamic_context_switching {
};
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &ctx).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &ctx).expect("Execution failed");
assert_eq!(errs, vec![]);
@ -633,7 +633,7 @@ mod dynamic_context_switching {
};
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &ctx).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &ctx).expect("Execution failed");
assert_eq!(
errs,
@ -682,7 +682,7 @@ mod dynamic_context_switching {
};
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &ctx).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &ctx).expect("Execution failed");
assert_eq!(
errs,
@ -743,7 +743,7 @@ mod dynamic_context_switching {
};
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &ctx).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &ctx).expect("Execution failed");
assert_eq!(errs, []);
@ -839,7 +839,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -866,7 +866,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -890,7 +890,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -914,7 +914,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -941,7 +941,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -965,7 +965,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -992,7 +992,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -1016,7 +1016,7 @@ mod propagates_errors_to_nullable_fields {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
println!("Result: {:#?}", result);
@ -1081,7 +1081,7 @@ mod named_operations {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -1099,7 +1099,7 @@ mod named_operations {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -1117,7 +1117,7 @@ mod named_operations {
let vars = vec![].into_iter().collect();
let (result, errs) = crate::execute(doc, Some("OtherExample"), &schema, &vars, &())
let (result, errs) = crate::execute_sync(doc, Some("OtherExample"), &schema, &vars, &())
.expect("Execution failed");
assert_eq!(errs, []);
@ -1135,7 +1135,7 @@ mod named_operations {
let vars = vec![].into_iter().collect();
let err = crate::execute(doc, None, &schema, &vars, &()).unwrap_err();
let err = crate::execute_sync(doc, None, &schema, &vars, &()).unwrap_err();
assert_eq!(err, GraphQLError::MultipleOperationsProvided);
}
@ -1147,7 +1147,8 @@ mod named_operations {
let vars = vec![].into_iter().collect();
let err = crate::execute(doc, Some("UnknownExample"), &schema, &vars, &()).unwrap_err();
let err =
crate::execute_sync(doc, Some("UnknownExample"), &schema, &vars, &()).unwrap_err();
assert_eq!(err, GraphQLError::UnknownOperationName);
}

4
juniper/src/executor_tests/interfaces_unions.rs
View file

@ -117,7 +117,7 @@ mod interface {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -264,7 +264,7 @@ mod union {
let vars = vec![].into_iter().collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/executor_tests/introspection/enums.rs
View file

@ -95,7 +95,7 @@ where
let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/executor_tests/introspection/input_object.rs
View file

@ -107,7 +107,7 @@ where
let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);

10
juniper/src/executor_tests/introspection/mod.rs
View file

@ -86,7 +86,7 @@ fn test_execution() {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);
@ -130,7 +130,7 @@ fn enum_introspection() {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);
@ -239,7 +239,7 @@ fn interface_introspection() {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);
@ -386,7 +386,7 @@ fn object_introspection() {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);
@ -593,7 +593,7 @@ fn scalar_introspection() {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);

38
juniper/src/executor_tests/variables.rs
View file

@ -133,7 +133,7 @@ where
let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(query, None, &schema, &vars, &()).expect("Execution failed");
crate::execute_sync(query, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);
@ -302,7 +302,7 @@ fn variable_error_on_nested_non_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -322,7 +322,7 @@ fn variable_error_on_incorrect_type() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -352,7 +352,7 @@ fn variable_error_on_omit_non_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -383,7 +383,7 @@ fn variable_multiple_errors_with_nesting() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -421,7 +421,7 @@ fn variable_error_on_additional_field() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -523,7 +523,7 @@ fn does_not_allow_non_nullable_input_to_be_omitted_in_variable() {
let query = r#"query q($value: String!) { fieldWithNonNullableStringInput(input: $value) }"#;
let vars = vec![].into_iter().collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -543,7 +543,7 @@ fn does_not_allow_non_nullable_input_to_be_set_to_null_in_variable() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -650,7 +650,7 @@ fn does_not_allow_non_null_lists_to_be_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -753,7 +753,7 @@ fn does_not_allow_lists_of_non_null_to_contain_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -780,7 +780,7 @@ fn does_not_allow_non_null_lists_of_non_null_to_contain_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -800,7 +800,7 @@ fn does_not_allow_non_null_lists_of_non_null_to_be_null() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -933,7 +933,7 @@ fn does_not_allow_missing_required_field() {
let query = r#"{ exampleInput(arg: {a: "abc"}) }"#;
let vars = vec![].into_iter().collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -951,7 +951,7 @@ fn does_not_allow_null_in_required_field() {
let query = r#"{ exampleInput(arg: {a: "abc", b: null}) }"#;
let vars = vec![].into_iter().collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -969,7 +969,7 @@ fn does_not_allow_missing_variable_for_required_field() {
let query = r#"query q($var: Int!) { exampleInput(arg: {b: $var}) }"#;
let vars = vec![].into_iter().collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -989,7 +989,7 @@ fn does_not_allow_null_variable_for_required_field() {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -1088,7 +1088,7 @@ mod integers {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -1108,7 +1108,7 @@ mod integers {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,
@ -1164,7 +1164,7 @@ mod floats {
.into_iter()
.collect();
let error = crate::execute(query, None, &schema, &vars, &()).unwrap_err();
let error = crate::execute_sync(query, None, &schema, &vars, &()).unwrap_err();
assert_eq!(
error,

8
juniper/src/http/mod.rs
View file

@ -74,7 +74,7 @@ where
///
/// This is a simple wrapper around the `execute` function exposed at the
/// top level of this crate.
pub fn execute<'a, CtxT, QueryT, MutationT>(
pub fn execute_sync<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a RootNode<QueryT, MutationT, S>,
context: &CtxT,
@ -84,7 +84,7 @@ where
QueryT: GraphQLType<S, Context = CtxT>,
MutationT: GraphQLType<S, Context = CtxT>,
{
GraphQLResponse(crate::execute(
GraphQLResponse(crate::execute_sync(
&self.query,
self.operation_name(),
root_node,
@ -93,7 +93,7 @@ where
))
}
pub async fn execute_async<'a, CtxT, QueryT, MutationT>(
pub async fn execute<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a RootNode<'a, QueryT, MutationT, S>,
context: &'a CtxT,
@ -108,7 +108,7 @@ where
{
let op = self.operation_name();
let vars = &self.variables();
let res = crate::execute_async(&self.query, op, root_node, vars, context).await;
let res = crate::execute(&self.query, op, root_node, vars, context).await;
GraphQLResponse(res)
}
}

4
juniper/src/integrations/chrono.rs
View file

@ -237,8 +237,8 @@ mod integration_test {
let schema = RootNode::new(Root, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
let (result, errs) = crate::execute_sync(doc, None, &schema, &Variables::new(), &())
.expect("Execution failed");
assert_eq!(errs, []);

6
juniper/src/lib.rs
View file

@ -219,7 +219,7 @@ impl<'a> fmt::Display for GraphQLError<'a> {
impl<'a> std::error::Error for GraphQLError<'a> {}
/// Execute a query in a provided schema
pub fn execute<'a, S, CtxT, QueryT, MutationT>(
pub fn execute_sync<'a, S, CtxT, QueryT, MutationT>(
document_source: &'a str,
operation_name: Option<&str>,
root_node: &'a RootNode<QueryT, MutationT, S>,
@ -257,7 +257,7 @@ where
}
/// Execute a query in a provided schema
pub async fn execute_async<'a, S, CtxT, QueryT, MutationT>(
pub async fn execute<'a, S, CtxT, QueryT, MutationT>(
document_source: &'a str,
operation_name: Option<&str>,
root_node: &'a RootNode<'a, QueryT, MutationT, S>,
@ -309,7 +309,7 @@ where
QueryT: GraphQLType<S, Context = CtxT>,
MutationT: GraphQLType<S, Context = CtxT>,
{
execute(
execute_sync(
match format {
IntrospectionFormat::All => INTROSPECTION_QUERY,
IntrospectionFormat::WithoutDescriptions => INTROSPECTION_QUERY_WITHOUT_DESCRIPTIONS,

2
juniper/src/macros/tests/args.rs
View file

@ -165,7 +165,7 @@ where
let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);

3
juniper/src/macros/tests/field.rs
View file

@ -164,7 +164,8 @@ where
.into_iter()
.collect();
let (result, errs) = crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) =
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/macros/tests/impl_object.rs
View file

@ -269,7 +269,7 @@ fn object_query() {
let schema = RootNode::new(Query { b: true }, EmptyMutation::<Context>::new());
let vars = std::collections::HashMap::new();
let (result, errs) = crate::execute(doc, None, &schema, &vars, &Context { flag1: true })
let (result, errs) = crate::execute_sync(doc, None, &schema, &vars, &Context { flag1: true })
.expect("Execution failed");
assert_eq!(errs, []);
assert_eq!(

3
juniper/src/macros/tests/interface.rs
View file

@ -171,7 +171,8 @@ where
.into_iter()
.collect();
let (result, errs) = crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) =
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/macros/tests/object.rs
View file

@ -173,7 +173,7 @@ where
.collect();
let (result, errs) =
crate::execute(doc, None, &schema, &vars, &InnerContext).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &vars, &InnerContext).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/macros/tests/scalar.rs
View file

@ -103,7 +103,7 @@ where
let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
let (result, errs) =
crate::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
crate::execute_sync(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
assert_eq!(errs, []);

3
juniper/src/macros/tests/union.rs
View file

@ -126,7 +126,8 @@ where
.into_iter()
.collect();
let (result, errs) = crate::execute(doc, None, &schema, &vars, &()).expect("Execution failed");
let (result, errs) =
crate::execute_sync(doc, None, &schema, &vars, &()).expect("Execution failed");
assert_eq!(errs, []);

2
juniper/src/macros/tests/util.rs
View file

@ -9,7 +9,7 @@ where
{
let schema = RootNode::new(Query::default(), Mutation::default());
let (result, errs) =
crate::execute(query, None, &schema, &Variables::new(), &Context::default())
crate::execute_sync(query, None, &schema, &Variables::new(), &Context::default())
.expect("Execution failed");
assert_eq!(errs, []);

14
juniper/src/tests/introspection_tests.rs
View file

@ -23,7 +23,7 @@ fn test_introspection_query_type_name() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
graphql_value!({
"__schema": {
@ -50,7 +50,7 @@ fn test_introspection_type_name() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
graphql_value!({
"__type": {
@ -76,7 +76,7 @@ fn test_introspection_specific_object_type_name_and_kind() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
graphql_value!({
"__type": {
@ -103,7 +103,7 @@ fn test_introspection_specific_interface_type_name_and_kind() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
graphql_value!({
"__type": {
@ -130,7 +130,7 @@ fn test_introspection_documentation() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
graphql_value!({
"__type": {
@ -159,7 +159,7 @@ fn test_introspection_directives() {
let database = Database::new();
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
let mut result = crate::execute(q, None, &schema, &Variables::new(), &database).unwrap();
let mut result = crate::execute_sync(q, None, &schema, &Variables::new(), &database).unwrap();
sort_schema_value(&mut result.0);
let mut expected = graphql_value!({
@ -203,7 +203,7 @@ fn test_introspection_possible_types() {
let database = Database::new();
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
let result = crate::execute(doc, None, &schema, &Variables::new(), &database);
let result = crate::execute_sync(doc, None, &schema, &Variables::new(), &database);
let (result, errors) = result.ok().expect("Query returned error");

30
juniper/src/tests/query_tests.rs
View file

@ -19,7 +19,7 @@ fn test_hero_name() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -47,7 +47,7 @@ fn test_hero_field_order() {
}
}"#;
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -76,7 +76,7 @@ fn test_hero_field_order() {
}
}"#;
assert_eq!(
crate::execute(doc_reversed, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc_reversed, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -114,7 +114,7 @@ fn test_hero_name_and_friends() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -176,7 +176,7 @@ fn test_hero_name_and_friends_and_friends_of_friends() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -337,7 +337,7 @@ fn test_query_name() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -363,7 +363,7 @@ fn test_query_alias_single() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -393,7 +393,7 @@ fn test_query_alias_multiple() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![
@ -438,7 +438,7 @@ fn test_query_alias_multiple_with_fragment() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![
@ -484,7 +484,7 @@ fn test_query_name_variable() {
.collect();
assert_eq!(
crate::execute(doc, None, &schema, &vars, &database),
crate::execute_sync(doc, None, &schema, &vars, &database),
Ok((
Value::object(
vec![(
@ -514,7 +514,7 @@ fn test_query_name_invalid_variable() {
.collect();
assert_eq!(
crate::execute(doc, None, &schema, &vars, &database),
crate::execute_sync(doc, None, &schema, &vars, &database),
Ok((
Value::object(vec![("human", Value::null())].into_iter().collect()),
vec![]
@ -529,7 +529,7 @@ fn test_query_friends_names() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -586,7 +586,7 @@ fn test_query_inline_fragments_droid() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -623,7 +623,7 @@ fn test_query_inline_fragments_human() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(
@ -657,7 +657,7 @@ fn test_object_typename() {
let schema = RootNode::new(Query, EmptyMutation::<Database>::new());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &database),
crate::execute_sync(doc, None, &schema, &Variables::new(), &database),
Ok((
Value::object(
vec![(

2
juniper/src/tests/type_info_tests.rs
View file

@ -77,7 +77,7 @@ fn test_node() {
let schema: RootNode<_, _> = RootNode::new_with_info(node, EmptyMutation::new(), node_info, ());
assert_eq!(
crate::execute(doc, None, &schema, &Variables::new(), &()),
crate::execute_sync(doc, None, &schema, &Variables::new(), &()),
Ok((
Value::object(
vec![

6
juniper_benchmarks/benches/benchmark.rs
View file

@ -38,7 +38,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
.collect::<Vec<_>>();
let ids = InputValue::list(ids);
b.iter(|| {
j::execute(
j::execute_sync(
SYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
)
@ -58,7 +58,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
let ids = InputValue::list(ids);
b.iter(|| {
let f = j::execute_async(
let f = j::execute(
ASYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
);
@ -77,7 +77,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
let ids = InputValue::list(ids);
b.iter(|| {
let f = j::execute_async(
let f = j::execute(
ASYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
);

8
juniper_benchmarks/src/lib.rs
View file

@ -99,16 +99,16 @@ pub fn new_schema() -> juniper::RootNode<'static, Query, Mutation> {
juniper::RootNode::new(Query, Mutation)
}
pub fn execute(query: &str, vars: Variables) -> QueryResult {
pub fn execute_sync(query: &str, vars: Variables) -> QueryResult {
let root = new_schema();
let ctx = Context::new();
juniper::execute(query, None, &root, &vars, &ctx).map_err(|e| format!("{:?}", e))
juniper::execute_sync(query, None, &root, &vars, &ctx).map_err(|e| format!("{:?}", e))
}
pub async fn execute_async(query: &str, vars: Variables) -> QueryResult {
pub async fn execute(query: &str, vars: Variables) -> QueryResult {
let root = new_schema();
let ctx = Context::new();
juniper::execute_async(query, None, &root, &vars, &ctx)
juniper::execute(query, None, &root, &vars, &ctx)
.await
.map_err(|e| format!("{:?}", e))
}

16
juniper_hyper/src/lib.rs
View file

@ -145,7 +145,7 @@ where
QueryT::TypeInfo: Send + Sync,
MutationT::TypeInfo: Send + Sync,
{
let (is_ok, body) = request.execute(root_node, context);
let (is_ok, body) = request.execute_sync(root_node, context);
let code = if is_ok {
StatusCode::OK
} else {
@ -173,7 +173,7 @@ where
QueryT::TypeInfo: Send + Sync,
MutationT::TypeInfo: Send + Sync,
{
let (is_ok, body) = request.execute_async(root_node, context).await;
let (is_ok, body) = request.execute(root_node, context).await;
let code = if is_ok {
StatusCode::OK
} else {
@ -267,7 +267,7 @@ impl<S> GraphQLRequest<S>
where
S: ScalarValue,
{
fn execute<'a, CtxT: 'a, QueryT, MutationT>(
fn execute_sync<'a, CtxT: 'a, QueryT, MutationT>(
self,
root_node: Arc<RootNode<'a, QueryT, MutationT, S>>,
context: Arc<CtxT>,
@ -279,7 +279,7 @@ where
{
match self {
GraphQLRequest::Single(request) => {
let res = request.execute(&root_node, &context);
let res = request.execute_sync(&root_node, &context);
let is_ok = res.is_ok();
let body = Body::from(serde_json::to_string_pretty(&res).unwrap());
(is_ok, body)
@ -289,7 +289,7 @@ where
.into_iter()
.map(move |request| {
let root_node = root_node.clone();
let res = request.execute(&root_node, &context);
let res = request.execute_sync(&root_node, &context);
let is_ok = res.is_ok();
let body = serde_json::to_string_pretty(&res).unwrap();
(is_ok, body)
@ -304,7 +304,7 @@ where
}
}
async fn execute_async<'a, CtxT: 'a, QueryT, MutationT>(
async fn execute<'a, CtxT: 'a, QueryT, MutationT>(
self,
root_node: Arc<RootNode<'a, QueryT, MutationT, S>>,
context: Arc<CtxT>,
@ -319,7 +319,7 @@ where
{
match self {
GraphQLRequest::Single(request) => {
let res = request.execute_async(&root_node, &context).await;
let res = request.execute(&root_node, &context).await;
let is_ok = res.is_ok();
let body = Body::from(serde_json::to_string_pretty(&res).unwrap());
(is_ok, body)
@ -327,7 +327,7 @@ where
GraphQLRequest::Batch(requests) => {
let futures = requests
.iter()
.map(|request| request.execute_async(&root_node, &context))
.map(|request| request.execute(&root_node, &context))
.collect::<Vec<_>>();
let results = futures::future::join_all(futures).await;

16
juniper_iron/src/lib.rs
View file

@ -146,7 +146,7 @@ impl<S> GraphQLBatchRequest<S>
where
S: ScalarValue,
{
pub fn execute<'a, CtxT, QueryT, MutationT>(
pub fn execute_sync<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a RootNode<QueryT, MutationT, S>,
context: &CtxT,
@ -157,12 +157,12 @@ where
{
match *self {
GraphQLBatchRequest::Single(ref request) => {
GraphQLBatchResponse::Single(request.execute(root_node, context))
GraphQLBatchResponse::Single(request.execute_sync(root_node, context))
}
GraphQLBatchRequest::Batch(ref requests) => GraphQLBatchResponse::Batch(
requests
.iter()
.map(|request| request.execute(root_node, context))
.map(|request| request.execute_sync(root_node, context))
.collect(),
),
}
@ -295,8 +295,12 @@ where
)
}
fn execute(&self, context: &CtxT, request: GraphQLBatchRequest<S>) -> IronResult<Response> {
let response = request.execute(&self.root_node, context);
fn execute_sync(
&self,
context: &CtxT,
request: GraphQLBatchRequest<S>,
) -> IronResult<Response> {
let response = request.execute_sync(&self.root_node, context);
let content_type = "application/json".parse::<Mime>().unwrap();
let json = serde_json::to_string_pretty(&response).unwrap();
let status = if response.is_ok() {
@ -351,7 +355,7 @@ where
_ => return Ok(Response::with(status::MethodNotAllowed)),
};
self.execute(&context, graphql_request)
self.execute_sync(&context, graphql_request)
}
}

4
juniper_rocket/examples/rocket_server.rs
View file

@ -20,7 +20,7 @@ fn get_graphql_handler(
request: juniper_rocket::GraphQLRequest,
schema: State<Schema>,
) -> juniper_rocket::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
#[rocket::post("/graphql", data = "<request>")]
@ -29,7 +29,7 @@ fn post_graphql_handler(
request: juniper_rocket::GraphQLRequest,
schema: State<Schema>,
) -> juniper_rocket::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
fn main() {

20
juniper_rocket/src/lib.rs
View file

@ -82,7 +82,7 @@ impl<S> GraphQLBatchRequest<S>
where
S: ScalarValue,
{
pub fn execute<'a, CtxT, QueryT, MutationT>(
pub fn execute_sync<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a RootNode<QueryT, MutationT, S>,
context: &CtxT,
@ -93,12 +93,12 @@ where
{
match self {
&GraphQLBatchRequest::Single(ref request) => {
GraphQLBatchResponse::Single(request.execute(root_node, context))
GraphQLBatchResponse::Single(request.execute_sync(root_node, context))
}
&GraphQLBatchRequest::Batch(ref requests) => GraphQLBatchResponse::Batch(
requests
.iter()
.map(|request| request.execute(root_node, context))
.map(|request| request.execute_sync(root_node, context))
.collect(),
),
}
@ -158,7 +158,7 @@ where
S: ScalarValue,
{
/// Execute an incoming GraphQL query
pub fn execute<CtxT, QueryT, MutationT>(
pub fn execute_sync<CtxT, QueryT, MutationT>(
&self,
root_node: &RootNode<QueryT, MutationT, S>,
context: &CtxT,
@ -167,7 +167,7 @@ where
QueryT: GraphQLType<S, Context = CtxT>,
MutationT: GraphQLType<S, Context = CtxT>,
{
let response = self.0.execute(root_node, context);
let response = self.0.execute_sync(root_node, context);
let status = if response.is_ok() {
Status::Ok
} else {
@ -221,7 +221,7 @@ impl GraphQLResponse {
/// return juniper_rocket::GraphQLResponse::error(err);
/// }
///
/// request.execute(&schema, &context)
/// request.execute_sync(&schema, &context)
/// }
/// ```
pub fn error(error: FieldError) -> Self {
@ -234,7 +234,7 @@ impl GraphQLResponse {
///
/// This is intended for highly customized integrations and should only
/// be used as a last resort. For normal juniper use, use the response
/// from GraphQLRequest::execute(..).
/// from GraphQLRequest::execute_sync(..).
pub fn custom(status: Status, response: serde_json::Value) -> Self {
let json = serde_json::to_string(&response).unwrap();
GraphQLResponse(status, json)
@ -500,7 +500,7 @@ mod tests {
request: Form<super::GraphQLRequest>,
schema: State<Schema>,
) -> super::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
#[post("/", data = "<request>")]
@ -509,7 +509,7 @@ mod tests {
request: super::GraphQLRequest,
schema: State<Schema>,
) -> super::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
struct TestRocketIntegration {
@ -546,7 +546,7 @@ mod tests {
schema: State<Schema>,
) -> super::GraphQLResponse {
assert_eq!(request.operation_names(), vec![Some("TestQuery")]);
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
let rocket = make_rocket_without_routes()

4
juniper_rocket_async/examples/rocket_server.rs
View file

@ -20,7 +20,7 @@ fn get_graphql_handler(
request: juniper_rocket::GraphQLRequest,
schema: State<Schema>,
) -> juniper_rocket::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
#[rocket::post("/graphql", data = "<request>")]
@ -29,7 +29,7 @@ fn post_graphql_handler(
request: juniper_rocket::GraphQLRequest,
schema: State<Schema>,
) -> juniper_rocket::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
fn main() {

26
juniper_rocket_async/src/lib.rs
View file

@ -94,18 +94,18 @@ where
{
match self {
&GraphQLBatchRequest::Single(ref request) => {
GraphQLBatchResponse::Single(request.execute(root_node, context))
GraphQLBatchResponse::Single(request.execute_sync(root_node, context))
}
&GraphQLBatchRequest::Batch(ref requests) => GraphQLBatchResponse::Batch(
requests
.iter()
.map(|request| request.execute(root_node, context))
.map(|request| request.execute_sync(root_node, context))
.collect(),
),
}
}
pub async fn execute_async<'a, CtxT, QueryT, MutationT>(
pub async fn execute<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a RootNode<'_, QueryT, MutationT, S>,
context: &'a CtxT,
@ -119,12 +119,12 @@ where
{
match self {
&GraphQLBatchRequest::Single(ref request) => {
GraphQLBatchResponse::Single(request.execute_async(root_node, context).await)
GraphQLBatchResponse::Single(request.execute(root_node, context).await)
}
&GraphQLBatchRequest::Batch(ref requests) => {
let futures = requests
.iter()
.map(|request| request.execute_async(root_node, context))
.map(|request| request.execute(root_node, context))
.collect::<Vec<_>>();
GraphQLBatchResponse::Batch(futures::future::join_all(futures).await)
@ -195,7 +195,7 @@ where
QueryT: GraphQLType<S, Context = CtxT>,
MutationT: GraphQLType<S, Context = CtxT>,
{
let response = self.0.execute(root_node, context);
let response = self.0.execute_sync(root_node, context);
let status = if response.is_ok() {
Status::Ok
} else {
@ -207,7 +207,7 @@ where
}
/// Asynchronously execute an incoming GraphQL query
pub async fn execute_async<CtxT, QueryT, MutationT>(
pub async fn execute<CtxT, QueryT, MutationT>(
&self,
root_node: &RootNode<'_, QueryT, MutationT, S>,
context: &CtxT,
@ -219,7 +219,7 @@ where
MutationT::TypeInfo: Send + Sync,
CtxT: Send + Sync,
{
let response = self.0.execute_async(root_node, context).await;
let response = self.0.execute(root_node, context).await;
let status = if response.is_ok() {
Status::Ok
} else {
@ -273,7 +273,7 @@ impl GraphQLResponse {
/// return juniper_rocket::GraphQLResponse::error(err);
/// }
///
/// request.execute(&schema, &context)
/// request.execute_sync(&schema, &context)
/// }
/// ```
pub fn error(error: FieldError) -> Self {
@ -286,7 +286,7 @@ impl GraphQLResponse {
///
/// This is intended for highly customized integrations and should only
/// be used as a last resort. For normal juniper use, use the response
/// from GraphQLRequest::execute(..).
/// from GraphQLRequest::execute_sync(..).
pub fn custom(status: Status, response: serde_json::Value) -> Self {
let json = serde_json::to_string(&response).unwrap();
GraphQLResponse(status, json)
@ -557,7 +557,7 @@ mod tests {
request: Form<super::GraphQLRequest>,
schema: State<Schema>,
) -> super::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
#[post("/", data = "<request>")]
@ -566,7 +566,7 @@ mod tests {
request: super::GraphQLRequest,
schema: State<Schema>,
) -> super::GraphQLResponse {
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
struct TestRocketIntegration {
@ -603,7 +603,7 @@ mod tests {
schema: State<Schema>,
) -> super::GraphQLResponse {
assert_eq!(request.operation_names(), vec![Some("TestQuery")]);
request.execute(&schema, &context)
request.execute_sync(&schema, &context)
}
let rocket = make_rocket_without_routes()

18
juniper_warp/src/lib.rs
View file

@ -75,18 +75,18 @@ where
{
match *self {
GraphQLBatchRequest::Single(ref request) => {
GraphQLBatchResponse::Single(request.execute(root_node, context))
GraphQLBatchResponse::Single(request.execute_sync(root_node, context))
}
GraphQLBatchRequest::Batch(ref requests) => GraphQLBatchResponse::Batch(
requests
.iter()
.map(|request| request.execute(root_node, context))
.map(|request| request.execute_sync(root_node, context))
.collect(),
),
}
}
pub async fn execute_async<'a, CtxT, QueryT, MutationT>(
pub async fn execute<'a, CtxT, QueryT, MutationT>(
&'a self,
root_node: &'a juniper::RootNode<'a, QueryT, MutationT, S>,
context: &'a CtxT,
@ -101,13 +101,13 @@ where
{
match self {
&GraphQLBatchRequest::Single(ref request) => {
let res = request.execute_async(root_node, context).await;
let res = request.execute(root_node, context).await;
GraphQLBatchResponse::Single(res)
}
&GraphQLBatchRequest::Batch(ref requests) => {
let futures = requests
.iter()
.map(|request| request.execute_async(root_node, context))
.map(|request| request.execute(root_node, context))
.collect::<Vec<_>>();
let responses = futures03::future::join_all(futures).await;
@ -218,7 +218,7 @@ where
Box::new(
poll_fn(move || {
tokio_threadpool::blocking(|| {
let response = request.execute(&schema, &context);
let response = request.execute_sync(&schema, &context);
Ok((serde_json::to_vec(&response)?, response.is_ok()))
})
})
@ -252,7 +252,7 @@ where
variables,
);
let response = graphql_request.execute(&schema, &context);
let response = graphql_request.execute_sync(&schema, &context);
Ok((serde_json::to_vec(&response)?, response.is_ok()))
})
})
@ -290,7 +290,7 @@ where
let schema = post_schema.clone();
let f = async move {
let res = request.execute_async(&schema, &context).await;
let res = request.execute(&schema, &context).await;
match serde_json::to_vec(&res) {
Ok(json) => Ok(build_response(Ok((json, res.is_ok())))),
@ -326,7 +326,7 @@ where
variables,
);
let response = graphql_request.execute(&schema, &context);
let response = graphql_request.execute_sync(&schema, &context);
Ok((serde_json::to_vec(&response)?, response.is_ok()))
})
})