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

Remove async-trait [skip ci]

Browse source
This commit is contained in:
nWacky 2019-11-13 16:49:06 +03:00 • committed by theduke
parent a5580a939d
commit 2144ad0d7d
9 changed files with 79 additions and 93 deletions

1
juniper/Cargo.toml
View file

@ -35,7 +35,6 @@ default = [
[dependencies] [dependencies]
juniper_codegen = { version = "0.14.1", path = "../juniper_codegen" } juniper_codegen = { version = "0.14.1", path = "../juniper_codegen" }
async-trait = "0.1.16"
chrono = { version = "0.4.0", optional = true } chrono = { version = "0.4.0", optional = true }
fnv = "1.0.3" fnv = "1.0.3"
futures = { version = "=0.3.1", optional = true } futures = { version = "=0.3.1", optional = true }

12
juniper/src/macros/scalar.rs
View file

@ -423,16 +423,12 @@ macro_rules! graphql_scalar {
) )
{ {
fn resolve_async<'a, 'async_trait>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a Self::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [$crate::Selection<'a, $crate::__juniper_insert_generic!($($scalar)+)>]>, selection_set: Option<&'a [$crate::Selection<$crate::__juniper_insert_generic!($($scalar)+)>]>,
executor: &'a $crate::Executor<'a, Self::Context, $crate::__juniper_insert_generic!($($scalar)+)>, executor: &'a $crate::Executor<Self::Context, $crate::__juniper_insert_generic!($($scalar)+)>,
) -> $crate::BoxFuture<'async_trait, $crate::Value<$crate::__juniper_insert_generic!($($scalar)+)>> ) -> $crate::BoxFuture<'a, $crate::Value<$crate::__juniper_insert_generic!($($scalar)+)>> {
where
'a: 'async_trait,
Self: 'async_trait,
{
use $crate::GraphQLType; use $crate::GraphQLType;
use futures::future; use futures::future;
let v = self.resolve(info, selection_set, executor); let v = self.resolve(info, selection_set, executor);

21
juniper/src/schema/schema.rs
View file

@ -77,7 +77,6 @@ where
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<'a, CtxT, S, QueryT, MutationT> crate::GraphQLTypeAsync<S> impl<'a, CtxT, S, QueryT, MutationT> crate::GraphQLTypeAsync<S>
for RootNode<'a, QueryT, MutationT, S> for RootNode<'a, QueryT, MutationT, S>
where where
@ -86,25 +85,25 @@ where
QueryT::TypeInfo: Send + Sync, QueryT::TypeInfo: Send + Sync,
MutationT: crate::GraphQLTypeAsync<S, Context = CtxT>, MutationT: crate::GraphQLTypeAsync<S, Context = CtxT>,
MutationT::TypeInfo: Send + Sync, MutationT::TypeInfo: Send + Sync,
CtxT: Send + Sync + 'a, CtxT: Send + Sync,
for<'c> &'c S: ScalarRefValue<'c>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_field_async<'b>( fn resolve_field_async<'b>(
&'b self, &'b self,
info: &'b <Self as crate::GraphQLType<S>>::TypeInfo, info: &'b Self::TypeInfo,
field_name: &'b str, field_name: &'b str,
arguments: &'b Arguments<'b, S>, arguments: &'b Arguments<S>,
executor: &'b Executor<'b, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'b Executor<Self::Context, S>,
) -> ExecutionResult<S> { ) -> crate::BoxFuture<'b, ExecutionResult<S>> {
use futures::future::{ready, FutureExt}; use futures::future::{ready, FutureExt};
match field_name { match field_name {
"__schema" | "__type" => { "__schema" | "__type" => {
self.resolve_field(info, field_name, arguments, executor) let v = self.resolve_field(info, field_name, arguments, executor);
Box::pin(ready(v))
} }
_ => self _ => self
.query_type .query_type
.resolve_field_async(info, field_name, arguments, executor) .resolve_field_async(info, field_name, arguments, executor),
.await
} }
} }
} }

28
juniper/src/types/async_await.rs
View file

@ -12,7 +12,6 @@ use crate::BoxFuture;
use super::base::{is_excluded, merge_key_into, Arguments, GraphQLType}; use super::base::{is_excluded, merge_key_into, Arguments, GraphQLType};
#[async_trait::async_trait]
pub trait GraphQLTypeAsync<S>: GraphQLType<S> + Send + Sync pub trait GraphQLTypeAsync<S>: GraphQLType<S> + Send + Sync
where where
Self::Context: Send + Sync, Self::Context: Send + Sync,
@ -20,38 +19,41 @@ where
S: ScalarValue + Send + Sync, S: ScalarValue + Send + Sync,
for<'b> &'b S: ScalarRefValue<'b>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_field_async<'a>( fn resolve_field_async<'a>(
&'a self, &'a self,
info: &'a Self::TypeInfo, info: &'a Self::TypeInfo,
field_name: &'a str, field_name: &'a str,
arguments: &'a Arguments<'a, S>, arguments: &'a Arguments<S>,
executor: &'a Executor<'a, Self::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> ExecutionResult<S> { ) -> BoxFuture<'a, ExecutionResult<S>> {
panic!("resolve_field must be implemented by object types"); panic!("resolve_field must be implemented by object types");
} }
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a Self::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, Self::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> Value<S> { ) -> BoxFuture<'a, Value<S>> {
if let Some(selection_set) = selection_set { if let Some(selection_set) = selection_set {
resolve_selection_set_into_async(self, info, selection_set, executor).await resolve_selection_set_into_async(self, info, selection_set, executor)
} else { } else {
panic!("resolve() must be implemented by non-object output types"); panic!("resolve() must be implemented by non-object output types");
} }
} }
async fn resolve_into_type_async<'a>( fn resolve_into_type_async<'a>(
&'a self, &'a self,
info: &'a Self::TypeInfo, info: &'a Self::TypeInfo,
type_name: &str, type_name: &str,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<'a, S>]>,
executor: &'a Executor<'a, Self::Context, S>, executor: &'a Executor<'a, Self::Context, S>,
) -> ExecutionResult<S> { ) -> BoxFuture<'a, ExecutionResult<S>> {
if Self::name(info).unwrap() == type_name { if Self::name(info).unwrap() == type_name {
Ok(self.resolve_async(info, selection_set, executor).await) Box::pin(async move {
let res = self.resolve_async(info, selection_set, executor).await;
Ok(res)
})
} else { } else {
panic!("resolve_into_type_async must be implemented by unions and interfaces"); panic!("resolve_into_type_async must be implemented by unions and interfaces");
} }

50
juniper/src/types/containers.rs
View file

@ -257,7 +257,6 @@ where
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for Vec<T> impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for Vec<T>
where where
T: crate::GraphQLTypeAsync<S, Context = CtxT>, T: crate::GraphQLTypeAsync<S, Context = CtxT>,
@ -266,18 +265,18 @@ where
CtxT: Send + Sync, CtxT: Send + Sync,
for<'b> &'b S: ScalarRefValue<'b>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a <Self as crate::GraphQLType<S>>::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> Value<S> { ) -> crate::BoxFuture<'a, Value<S>> {
resolve_into_list_async(executor, info, self.iter()).await let f = resolve_into_list_async(executor, info, self.iter());
Box::pin(f)
} }
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for &[T] impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for &[T]
where where
T: crate::GraphQLTypeAsync<S, Context = CtxT>, T: crate::GraphQLTypeAsync<S, Context = CtxT>,
@ -286,18 +285,18 @@ where
CtxT: Send + Sync, CtxT: Send + Sync,
for<'b> &'b S: ScalarRefValue<'b>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a <Self as crate::GraphQLType<S>>::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> Value<S> { ) -> crate::BoxFuture<'a, Value<S>> {
resolve_into_list_async(executor, info, self.iter()).await let f = resolve_into_list_async(executor, info, self.iter());
Box::pin(f)
} }
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for Option<T> impl<S, T, CtxT> crate::GraphQLTypeAsync<S> for Option<T>
where where
T: crate::GraphQLTypeAsync<S, Context = CtxT>, T: crate::GraphQLTypeAsync<S, Context = CtxT>,
@ -306,15 +305,18 @@ where
CtxT: Send + Sync, CtxT: Send + Sync,
for<'b> &'b S: ScalarRefValue<'b>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a <Self as crate::GraphQLType<S>>::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> Value<S> { ) -> crate::BoxFuture<'a, Value<S>> {
match *self { let f = async move {
Some(ref obj) => executor.resolve_into_value_async(info, obj).await, match *self {
None => Value::null(), Some(ref obj) => executor.resolve_into_value_async(info, obj).await,
} None => Value::null(),
}
};
Box::pin(f)
} }
} }

24
juniper/src/types/pointers.rs
View file

@ -137,7 +137,6 @@ where
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<'e, S, T> crate::GraphQLTypeAsync<S> for &'e T impl<'e, S, T> crate::GraphQLTypeAsync<S> for &'e T
where where
S: ScalarValue + Send + Sync, S: ScalarValue + Send + Sync,
@ -146,24 +145,23 @@ where
T::Context: Send + Sync, T::Context: Send + Sync,
for<'c> &'c S: ScalarRefValue<'c>, for<'c> &'c S: ScalarRefValue<'c>,
{ {
async fn resolve_field_async<'b>( fn resolve_field_async<'b>(
&'b self, &'b self,
info: &'b <Self as crate::GraphQLType<S>>::TypeInfo, info: &'b Self::TypeInfo,
field_name: &'b str, field_name: &'b str,
arguments: &'b Arguments<'b, S>, arguments: &'b Arguments<S>,
executor: &'b Executor<'b, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'b Executor<Self::Context, S>,
) -> ExecutionResult<S> { ) -> crate::BoxFuture<'b, ExecutionResult<S>> {
crate::GraphQLTypeAsync::resolve_field_async(&**self, info, field_name, arguments, executor) crate::GraphQLTypeAsync::resolve_field_async(&**self, info, field_name, arguments, executor)
.await
} }
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a <Self as crate::GraphQLType<S>>::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> Value<S> { ) -> crate::BoxFuture<'a, Value<S>> {
crate::GraphQLTypeAsync::resolve_async(&**self, info, selection_set, executor).await crate::GraphQLTypeAsync::resolve_async(&**self, info, selection_set, executor)
} }
} }

14
juniper/src/types/scalars.rs
View file

@ -197,19 +197,19 @@ where
} }
#[cfg(feature = "async")] #[cfg(feature = "async")]
#[async_trait::async_trait]
impl<'e, S> crate::GraphQLTypeAsync<S> for &'e str impl<'e, S> crate::GraphQLTypeAsync<S> for &'e str
where where
S: ScalarValue + Send + Sync, S: ScalarValue + Send + Sync,
for<'b> &'b S: ScalarRefValue<'b>, for<'b> &'b S: ScalarRefValue<'b>,
{ {
async fn resolve_async<'a>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a <Self as crate::GraphQLType<S>>::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [Selection<'a, S>]>, selection_set: Option<&'a [Selection<S>]>,
executor: &'a Executor<'a, <Self as crate::GraphQLType<S>>::Context, S>, executor: &'a Executor<Self::Context, S>,
) -> crate::Value<S> { ) -> crate::BoxFuture<'a, crate::Value<S>> {
self.resolve(info, selection_set, executor) use futures::future;
future::FutureExt::boxed(future::ready(self.resolve(info, selection_set, executor)))
} }
} }

8
juniper_codegen/src/derive_enum.rs
View file

@ -213,16 +213,12 @@ pub fn impl_enum(ast: &syn::DeriveInput, is_internal: bool) -> TokenStream {
__S: #juniper_path::ScalarValue + Send + Sync, __S: #juniper_path::ScalarValue + Send + Sync,
for<'__b> &'__b __S: #juniper_path::ScalarRefValue<'__b> for<'__b> &'__b __S: #juniper_path::ScalarRefValue<'__b>
{ {
fn resolve_async<'a, 'async_trait>( fn resolve_async<'a>(
&'a self, &'a self,
info: &'a Self::TypeInfo, info: &'a Self::TypeInfo,
selection_set: Option<&'a [#juniper_path::Selection<__S>]>, selection_set: Option<&'a [#juniper_path::Selection<__S>]>,
executor: &'a #juniper_path::Executor<Self::Context, __S>, executor: &'a #juniper_path::Executor<Self::Context, __S>,
) -> #juniper_path::BoxFuture<'async_trait, #juniper_path::Value<__S>> ) -> #juniper_path::BoxFuture<'a, #juniper_path::Value<__S>> {
where
'a: 'async_trait,
Self: 'async_trait
{
use #juniper_path::GraphQLType; use #juniper_path::GraphQLType;
use futures::future; use futures::future;
let v = self.resolve(info, selection_set, executor); let v = self.resolve(info, selection_set, executor);

14
juniper_codegen/src/util.rs
View file

@ -932,27 +932,21 @@ impl GraphQLTypeDefiniton {
impl#impl_generics #juniper_crate_name::GraphQLTypeAsync<#scalar> for #ty #type_generics_tokens impl#impl_generics #juniper_crate_name::GraphQLTypeAsync<#scalar> for #ty #type_generics_tokens
#where_async #where_async
{ {
fn resolve_field_async<'b, 'async_trait>( fn resolve_field_async<'b>(
&'b self, &'b self,
info: &'b Self::TypeInfo, info: &'b Self::TypeInfo,
field: &'b str, field: &'b str,
args: &'b #juniper_crate_name::Arguments<#scalar>, args: &'b #juniper_crate_name::Arguments<#scalar>,
executor: &'b #juniper_crate_name::Executor<Self::Context, #scalar>, executor: &'b #juniper_crate_name::Executor<Self::Context, #scalar>,
) -> #juniper_crate_name::BoxFuture<'async_trait, #juniper_crate_name::ExecutionResult<#scalar>> ) -> #juniper_crate_name::BoxFuture<'b, #juniper_crate_name::ExecutionResult<#scalar>>
where where #scalar: Send + Sync,
#scalar: Send + Sync,
'b: 'async_trait,
Self: 'async_trait,
{ {
use futures::future; use futures::future;
use #juniper_crate_name::GraphQLType; use #juniper_crate_name::GraphQLType;
match field { match field {
#( #resolve_matches_async )* #( #resolve_matches_async )*
_ => { _ => {
panic!("Field {} not found on type {:?}", panic!("Field {} not found on type {}", field, "Mutation");
field,
<Self as #juniper_crate_name::GraphQLType<#scalar>>::name(info)
);
} }
} }
} }