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

Impl fields resolving, vol.3 [skip ci]

Browse source
This commit is contained in:
tyranron 2022-09-09 14:39:32 +03:00
parent d1f2173109
commit 129ff559d1
No known key found for this signature in database
GPG key ID: 762E144FB230A4F0
7 changed files with 323 additions and 335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
juniper_codegen/src/common/gen.rs
View file

@ -1,7 +1,81 @@
//! Common code generated parts, used by this crate.
use proc_macro2::TokenStream;
use quote::quote;
use quote::{quote, ToTokens};
use syn::parse_quote;
use crate::common::{behavior};
/// Returns generated code implementing [`resolve::Resolvable`] trait for the
/// provided [`syn::Type`] with its [`syn::Generics`].
///
/// [`resolve::Resolvable`]: juniper::resolve::Resolvable
/// [0]: https://spec.graphql.org/October2021#sec-Interfaces
pub(crate) fn impl_resolvable(
bh: &behavior::Type,
(ty, generics): (syn::Type, syn::Generics),
) -> TokenStream {
let (sv, generics) = mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Resolvable<#sv, #bh>
for #ty #where_clause
{
type Value = Self;
fn into_value(self) -> ::juniper::FieldResult<Self, #sv> {
::juniper::FieldResult::Ok(self)
}
}
}
}
/// Mixes a type info [`syn::GenericParam`] into the provided [`syn::Generics`]
/// and returns its [`syn::Ident`].
#[must_use]
pub(crate) fn mix_type_info(mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __TypeInfo };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a context [`syn::GenericParam`] into the provided [`syn::Generics`]
/// and returns its [`syn::Ident`].
pub(crate) fn mix_context(mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __Context };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a [`ScalarValue`] [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
/// [`ScalarValue`]: juniper::ScalarValue
pub(crate) fn mix_scalar_value(mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let sv = parse_quote! { __ScalarValue };
generics.params.push(parse_quote! { #sv });
(sv, generics)
}
/// Mixes an [`InputValue`]'s lifetime [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
/// [`InputValue`]: juniper::resolve::InputValue
#[must_use]
pub(crate) fn mix_input_lifetime(
mut generics: syn::Generics,
sv: impl ToTokens,
) -> (syn::GenericParam, syn::Generics) {
let lt: syn::GenericParam = parse_quote! { '__inp };
generics.params.push(lt.clone());
generics
.make_where_clause()
.predicates
.push(parse_quote! { #sv: #lt });
(lt, generics)
}
/// Generate the code resolving some [GraphQL type][1] in a synchronous manner.
///

117
juniper_codegen/src/graphql_enum/mod.rs
View file

@ -15,7 +15,7 @@ use syn::{
};
use crate::common::{
behavior, deprecation, filter_attrs,
behavior, deprecation, filter_attrs, gen,
parse::{
attr::{err, OptionExt as _},
ParseBufferExt as _,
@ -417,7 +417,7 @@ impl ToTokens for Definition {
self.impl_resolve_type_name().to_tokens(into);
self.impl_resolve_value().to_tokens(into);
self.impl_resolve_value_async().to_tokens(into);
self.impl_resolvable().to_tokens(into);
gen::impl_resolvable(&self.behavior, self.ty_and_generics()).to_tokens(into);
self.impl_resolve_to_input_value().to_tokens(into);
self.impl_resolve_input_value().to_tokens(into);
self.impl_graphql_input_type().to_tokens(into);
@ -463,9 +463,9 @@ impl Definition {
fn impl_graphql_input_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::resolve::Type<#inf, #sv, #bh>
+ ::juniper::resolve::ToInputValue<#sv, #bh>
@ -492,9 +492,9 @@ impl Definition {
fn impl_graphql_output_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::resolve::Type<#inf, #sv, #bh>
+ ::juniper::resolve::Value<#inf, #cx, #sv, #bh>
@ -521,10 +521,10 @@ impl Definition {
fn impl_graphql_enum(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::graphql::InputType<#lt, #inf, #sv, #bh>
+ ::juniper::graphql::OutputType<#inf, #cx, #sv, #bh>
@ -608,8 +608,8 @@ impl Definition {
fn impl_resolve_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
let preds = &mut generics.make_where_clause().predicates;
preds.push(parse_quote! { #sv: Clone });
preds.push(parse_quote! {
@ -665,7 +665,7 @@ impl Definition {
fn impl_resolve_type_name(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
@ -746,9 +746,9 @@ impl Definition {
fn impl_resolve_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
generics.make_where_clause().predicates.push(parse_quote! {
#sv: From<String>
});
@ -835,9 +835,9 @@ impl Definition {
fn impl_resolve_value_async(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
let preds = &mut generics.make_where_clause().predicates;
preds.push(parse_quote! {
Self: ::juniper::resolve::Value<#inf, #cx, #sv, #bh>
@ -869,31 +869,6 @@ impl Definition {
}
}
/// Returns generated code implementing [`resolve::Resolvable`] trait for
/// this [GraphQL enum][0].
///
/// [`resolve::Resolvable`]: juniper::resolve::Resolvable
/// [0]: https://spec.graphql.org/October2021#sec-Enums
fn impl_resolvable(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, generics) = self.mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Resolvable<#sv, #bh>
for #ty #where_clause
{
type Value = Self;
fn into_value(self) -> ::juniper::FieldResult<Self, #sv> {
::juniper::FieldResult::Ok(self)
}
}
}
}
/// Returns generated code implementing [`FromInputValue`] trait for this
/// [GraphQL enum][0].
///
@ -941,8 +916,8 @@ impl Definition {
fn impl_resolve_input_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
#sv: ::juniper::ScalarValue
});
@ -1035,7 +1010,7 @@ impl Definition {
fn impl_resolve_to_input_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, mut generics) = self.mix_scalar_value(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
generics.make_where_clause().predicates.push(parse_quote! {
#sv: From<String>
});
@ -1226,48 +1201,4 @@ impl Definition {
};
(ty, generics)
}
/// Mixes a type info [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
fn mix_type_info(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __TypeInfo };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a context [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
fn mix_context(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __Context };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a [`ScalarValue`] [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
/// [`ScalarValue`]: juniper::ScalarValue
fn mix_scalar_value(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let sv = parse_quote! { __ScalarValue };
generics.params.push(parse_quote! { #sv });
(sv, generics)
}
/// Mixes an [`InputValue`]'s lifetime [`syn::GenericParam`] into the
/// provided [`syn::Generics`] and returns it.
///
/// [`InputValue`]: juniper::resolve::InputValue
fn mix_input_lifetime(
&self,
mut generics: syn::Generics,
sv: &syn::Ident,
) -> (syn::GenericParam, syn::Generics) {
let lt: syn::GenericParam = parse_quote! { '__inp };
generics.params.push(lt.clone());
generics
.make_where_clause()
.predicates
.push(parse_quote! { #sv: #lt });
(lt, generics)
}
}

62
juniper_codegen/src/graphql_input_object/mod.rs
View file

@ -15,7 +15,7 @@ use syn::{
};
use crate::common::{
behavior, default, filter_attrs,
behavior, default, filter_attrs, gen,
parse::{
attr::{err, OptionExt as _},
ParseBufferExt as _,
@ -520,9 +520,9 @@ impl Definition {
fn impl_graphql_input_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::resolve::Type<#inf, #sv, #bh>
+ ::juniper::resolve::ToInputValue<#sv, #bh>
@ -572,9 +572,9 @@ impl Definition {
fn impl_graphql_input_object(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::graphql::InputType<#lt, #inf, #sv, #bh>
});
@ -661,8 +661,8 @@ impl Definition {
fn impl_resolve_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
let preds = &mut generics.make_where_clause().predicates;
preds.push(parse_quote! { #sv: Clone });
preds.push(parse_quote! {
@ -751,7 +751,7 @@ impl Definition {
fn impl_resolve_type_name(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
@ -905,8 +905,8 @@ impl Definition {
fn impl_resolve_input_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, &sv);
let (sv, generics) = gen::mix_scalar_value(generics);
let (lt, mut generics) = gen::mix_input_lifetime(generics, &sv);
generics.make_where_clause().predicates.push(parse_quote! {
#sv: ::juniper::ScalarValue
});
@ -1033,7 +1033,7 @@ impl Definition {
fn impl_resolve_to_input_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, mut generics) = self.mix_scalar_value(generics);
let (sv, mut generics) = gen::mix_scalar_value(generics);
for f in self.fields.iter().filter(|f| !f.ignored) {
let field_ty = &f.ty;
let field_bh = &f.behavior;
@ -1225,40 +1225,4 @@ impl Definition {
};
(ty, generics)
}
/// Mixes a type info [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
fn mix_type_info(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __TypeInfo };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a [`ScalarValue`] [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
/// [`ScalarValue`]: juniper::ScalarValue
fn mix_scalar_value(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let sv = parse_quote! { __ScalarValue };
generics.params.push(parse_quote! { #sv });
(sv, generics)
}
/// Mixes an [`InputValue`]'s lifetime [`syn::GenericParam`] into the
/// provided [`syn::Generics`] and returns it.
///
/// [`InputValue`]: juniper::resolve::InputValue
fn mix_input_lifetime(
&self,
mut generics: syn::Generics,
sv: &syn::Ident,
) -> (syn::GenericParam, syn::Generics) {
let lt: syn::GenericParam = parse_quote! { '__inp };
generics.params.push(lt.clone());
generics
.make_where_clause()
.predicates
.push(parse_quote! { #sv: #lt });
(lt, generics)
}
}

32
juniper_codegen/src/graphql_interface/mod.rs
View file

@ -395,6 +395,8 @@ impl ToTokens for Definition {
self.impl_field_tokens().to_tokens(into);
self.impl_async_field_tokens().to_tokens(into);
////////////////////////////////////////////////////////////////////////
self.impl_resolve_value().to_tokens(into);
gen::impl_resolvable(&self.behavior, self.ty_and_generics()).to_tokens(into);
self.impl_reflect().to_tokens(into);
}
}
@ -850,6 +852,36 @@ impl Definition {
}
}
/// Returns generated code implementing [`resolve::Value`] trait for this
/// [GraphQL interface][0].
///
/// [`resolve::Value`]: juniper::resolve::Value
/// [0]: https://spec.graphql.org/October2021#sec-Interfaces
fn impl_resolve_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Value<#inf, #cx, #sv, #bh>
for #ty #where_clause
{
fn resolve_value(
&self,
_: Option<&[::juniper::Selection<'_, #sv>]>,
_: &#inf,
_: &::juniper::Executor<'_, '_, #cx, #sv>,
) -> ::juniper::ExecutionResult<#sv> {
todo!()
}
}
}
}
/// Returns generated code implementing [`GraphQLValueAsync`] trait for this
/// [GraphQL interface][1].
///

239
juniper_codegen/src/graphql_object/mod.rs
View file

@ -352,34 +352,8 @@ impl<Operation: ?Sized + 'static> Definition<Operation> {
/// Returns prepared self [`syn::Type`] and [`syn::Generics`] for a trait
/// implementation.
fn ty_and_generics(&self) -> (&syn::Type, syn::Generics) {
(&self.ty, self.generics.clone())
}
/// Mixes a type info [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
fn mix_type_info(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __TypeInfo };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a context [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
fn mix_context(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __Context };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a [`ScalarValue`] [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
/// [`ScalarValue`]: juniper::ScalarValue
fn mix_scalar_value(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let sv = parse_quote! { __ScalarValue };
generics.params.push(parse_quote! { #sv });
(sv, generics)
fn ty_and_generics(&self) -> (syn::Type, syn::Generics) {
(self.ty.clone(), self.generics.clone())
}
/// Returns generated code implementing [`marker::IsOutputType`] trait for
@ -599,108 +573,149 @@ impl<Operation: ?Sized + 'static> Definition<Operation> {
})
.collect()
}
/*
/// Returns generated code implementing [`resolve::StaticField`] trait for
/// each [field][1] of this [GraphQL object][0].
///
/// [`resolve::StaticField`]: juniper::resolve::StaticField
/// [0]: https://spec.graphql.org/October2021#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Language.Fields
#[must_use]
pub(crate) fn impl_resolve_static_field(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (sv, generics) = self.mix_scalar_value(generics);
self.fields
.iter()
.map(|field| {
let mut generics = generics.clone();
let (f_name, f_bh) = (&field.name, &field.behavior);
let (f_ident, f_ty) = (&field.ident, &field.ty);
/// Returns generated code implementing [`resolve::Value`] trait for this
/// [GraphQL object][0].
///
/// [`resolve::Value`]: juniper::resolve::Value
/// [0]: https://spec.graphql.org/October2021#sec-Objects
pub(crate) fn impl_resolve_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
let body = if !field.is_async {
generics.make_where_clause().predicates.push(parse_quote! {
#f_ty: ::juniper::resolve::Value<#inf, #cx, #sv, #f_bh>
});
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Value<#inf, #cx, #sv, #bh>
for #ty #where_clause
{
fn resolve_value(
&self,
_: Option<&[::juniper::Selection<'_, #sv>]>,
_: &#inf,
_: &::juniper::Executor<'_, '_, #cx, #sv>,
) -> ::juniper::ExecutionResult<#sv> {
todo!()
}
}
}
}
let res = if field.is_method() {
let args = field.arguments.as_ref().unwrap().iter().map(|arg| {
match arg {
field::MethodArgument::Regular(arg) => {
let (a_ty, a_bh) = (&arg.ty, &arg.behavior);
generics.make_where_clause().predicates.push(parse_quote! {
#a_ty: ::juniper::resolve::InputValueOwned<#sv, #a_bh>
});
quote! {
args.resolve::<#a_ty, #a_bh>(#name)?
}
/// Returns generated code implementing [`resolve::StaticField`] trait for
/// each [field][1] of this [GraphQL object][0].
///
/// [`resolve::StaticField`]: juniper::resolve::StaticField
/// [0]: https://spec.graphql.org/October2021#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Language.Fields
#[must_use]
pub(crate) fn impl_resolve_static_field(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
self.fields
.iter()
.map(|field| {
let mut generics = generics.clone();
let (f_name, f_bh) = (&field.name, &field.behavior);
let (f_ident, f_ty) = (&field.ident, &field.ty);
let body = if !field.is_async {
generics.make_where_clause().predicates.push(parse_quote! {
#f_ty: ::juniper::resolve::Resolvable<#sv, #f_bh>
});
generics.make_where_clause().predicates.push(parse_quote! {
<#f_ty as ::juniper::resolve::Resolvable<#sv, #f_bh>>::Value:
::juniper::resolve::Value<#inf, #cx, #sv, #f_bh>
});
let res = if field.is_method() {
let args = field
.arguments
.as_ref()
.unwrap()
.iter()
.map(|arg| match arg {
field::MethodArgument::Regular(arg) => {
let a_name = &arg.name;
let (a_ty, a_bh) = (&arg.ty, &arg.behavior);
generics.make_where_clause().predicates.push(parse_quote! {
#a_ty: ::juniper::resolve::InputValueOwned<#sv, #a_bh>
});
quote! {
args.resolve::<#a_ty, #a_bh>(#a_name)?
}
field::MethodArgument::Context(cx_ty) => {
generics.make_where_clause().predicates.push(parse_quote! {
#cx: ::juniper::Extract<#cx_ty>
});
quote! {
<#cx as ::juniper::Extract<#cx_ty>>
::extract(executor.context())
}
}
field::MethodArgument::Context(cx_ty) => {
generics.make_where_clause().predicates.push(parse_quote! {
#cx: ::juniper::Extract<#cx_ty>
});
quote! {
<#cx as ::juniper::Extract<#cx_ty>>
::extract(executor.context())
}
field::MethodArgument::Executor => {
quote! {
executor
}
}
field::MethodArgument::Executor => {
quote! {
executor
}
}
});
let rcv = field.has_receiver.then(|| {
quote! { self, }
});
quote! { Self::#ident(#rcv #( #args ),*) }
} else {
quote! {
&self.#f_ident
}
};
let rcv = field.has_receiver.then(|| {
quote! { self, }
});
quote! {
executor.resolve_value::<#f_bh, _, _>(#res, type_info)
<#f_ty as ::juniper::resolve::Resolvable<#sv, #f_bh>>
::into_value(Self::#f_ident(#rcv #( #args ),*))?
}
} else {
quote! {
::std::panic!(
"Tried to resolve async field `{}` on type `{}` with a sync resolver",
#f_name,
<Self as ::juniper::reflect::BaseType<#bh>>::NAME,
);
&self.#f_ident
}
};
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::StaticField<
{ ::juniper::reflect::fnv1a128(#f_name) },
#inf, #cx, #sv, #bh,
> for #ty #where_clause {
fn resolve_static_field(
&self,
args: &::juniper::Arguments<'_, #sv>,
type_info: &#inf,
executor: &::juniper::Executor<'_, '_, #cx, #sv>,
) -> ::juniper::ExecutionResult<#sv> {
#body
}
executor.resolve_value::<#f_bh, _, _>(#res, type_info)
}
} else {
quote! {
::std::panic!(
"Tried to resolve async field `{}` on type `{}` with a sync resolver",
#f_name,
<Self as ::juniper::reflect::BaseType<#bh>>::NAME,
);
}
};
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::StaticField<
{ ::juniper::reflect::fnv1a128(#f_name) },
#inf, #cx, #sv, #bh,
> for #ty #where_clause {
fn resolve_static_field(
&self,
args: &::juniper::Arguments<'_, #sv>,
type_info: &#inf,
executor: &::juniper::Executor<'_, '_, #cx, #sv>,
) -> ::juniper::ExecutionResult<#sv> {
#body
}
}
})
.collect()
}
*/
}
})
.collect()
}
/// Returns generated code implementing [`GraphQLType`] trait for this
/// [GraphQL object][1].
///
@ -780,9 +795,11 @@ impl ToTokens for Definition<Query> {
self.impl_field_tokens().to_tokens(into);
self.impl_async_field_tokens().to_tokens(into);
////////////////////////////////////////////////////////////////////////
self.impl_resolve_value().to_tokens(into);
gen::impl_resolvable(&self.behavior, self.ty_and_generics()).to_tokens(into);
self.impl_resolve_static_field().to_tokens(into);
self.impl_reflect().to_tokens(into);
self.impl_reflect_field().to_tokens(into);
//self.impl_resolve_static_field().to_tokens(into);
}
}

100
juniper_codegen/src/graphql_scalar/mod.rs
View file

@ -2,6 +2,9 @@
//!
//! [1]: https://spec.graphql.org/October2021#sec-Scalars
pub mod attr;
pub mod derive;
use proc_macro2::{Literal, TokenStream};
use quote::{format_ident, quote, ToTokens, TokenStreamExt};
use syn::{
@ -15,7 +18,7 @@ use syn::{
use url::Url;
use crate::common::{
behavior, filter_attrs,
behavior, filter_attrs, gen,
parse::{
attr::{err, OptionExt as _},
ParseBufferExt as _,
@ -23,9 +26,6 @@ use crate::common::{
scalar, Description, SpanContainer,
};
pub mod attr;
pub mod derive;
/// Available arguments behind `#[graphql]`/`#[graphql_scalar]` attributes when
/// generating code for [GraphQL scalar][1].
///
@ -351,7 +351,7 @@ impl ToTokens for Definition {
self.impl_resolve_type_name().to_tokens(into);
self.impl_resolve_value().to_tokens(into);
self.impl_resolve_value_async().to_tokens(into);
self.impl_resolvable().to_tokens(into);
gen::impl_resolvable(&self.behavior, self.ty_and_generics()).to_tokens(into);
self.impl_resolve_to_input_value().to_tokens(into);
self.impl_resolve_input_value().to_tokens(into);
self.impl_resolve_scalar_token().to_tokens(into);
@ -396,9 +396,9 @@ impl Definition {
fn impl_graphql_input_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, sv);
let (lt, mut generics) = gen::mix_input_lifetime(generics, sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::resolve::Type<#inf, #sv, #bh>
+ ::juniper::resolve::ToInputValue<#sv, #bh>
@ -425,8 +425,8 @@ impl Definition {
fn impl_graphql_output_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::resolve::Type<#inf, #sv, #bh>
@ -454,10 +454,10 @@ impl Definition {
fn impl_graphql_scalar(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, sv);
let (lt, mut generics) = gen::mix_input_lifetime(generics, sv);
generics.make_where_clause().predicates.push(parse_quote! {
Self: ::juniper::graphql::InputType<#lt, #inf, #sv, #bh>
+ ::juniper::graphql::OutputType<#inf, #cx, #sv, #bh>
@ -531,7 +531,7 @@ impl Definition {
fn impl_resolve_type_name(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
@ -554,7 +554,7 @@ impl Definition {
fn impl_resolve_type(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let preds = &mut generics.make_where_clause().predicates;
preds.push(parse_quote! { #sv: Clone });
@ -639,8 +639,8 @@ impl Definition {
fn impl_resolve_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
generics
.make_where_clause()
@ -705,8 +705,8 @@ impl Definition {
fn impl_resolve_value_async(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = self.mix_type_info(generics);
let (cx, generics) = self.mix_context(generics);
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, mut generics) = self.mix_scalar_value(generics);
let preds = &mut generics.make_where_clause().predicates;
preds.push(parse_quote! {
@ -739,31 +739,6 @@ impl Definition {
}
}
/// Returns generated code implementing [`resolve::Resolvable`] trait for
/// this [GraphQL scalar][0].
///
/// [`resolve::Resolvable`]: juniper::resolve::Resolvable
/// [0]: https://spec.graphql.org/October2021#sec-Scalars
fn impl_resolvable(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, generics) = self.mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Resolvable<#sv, #bh>
for #ty #where_clause
{
type Value = Self;
fn into_value(self) -> ::juniper::FieldResult<Self, #sv> {
::juniper::FieldResult::Ok(self)
}
}
}
}
/// Returns generated code implementing [`InputValue`] trait for this
/// [GraphQL scalar][1].
///
@ -855,7 +830,7 @@ impl Definition {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (sv, generics) = self.mix_scalar_value(generics);
let (lt, mut generics) = self.mix_input_lifetime(generics, sv);
let (lt, mut generics) = gen::mix_input_lifetime(generics, sv);
generics
.make_where_clause()
.predicates
@ -1111,24 +1086,6 @@ impl Definition {
(ty, generics)
}
/// Mixes a type info [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
#[must_use]
fn mix_type_info(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __TypeInfo };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a context [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns its [`syn::Ident`].
#[must_use]
fn mix_context(&self, mut generics: syn::Generics) -> (syn::Ident, syn::Generics) {
let ty = parse_quote! { __Context };
generics.params.push(parse_quote! { #ty: ?Sized });
(ty, generics)
}
/// Mixes a [`ScalarValue`] [`syn::GenericParam`] into the provided
/// [`syn::Generics`] and returns it.
///
@ -1143,25 +1100,6 @@ impl Definition {
generics.params.push(parse_quote! { #sv });
(sv, generics)
}
/// Mixes an [`InputValue`]'s lifetime [`syn::GenericParam`] into the
/// provided [`syn::Generics`] and returns it.
///
/// [`InputValue`]: juniper::resolve::InputValue
#[must_use]
fn mix_input_lifetime(
&self,
mut generics: syn::Generics,
sv: &ScalarValue,
) -> (syn::GenericParam, syn::Generics) {
let lt: syn::GenericParam = parse_quote! { '__inp };
generics.params.push(lt.clone());
generics
.make_where_clause()
.predicates
.push(parse_quote! { #sv: #lt });
(lt, generics)
}
}
/// Adds `__fa__` prefix to all lifetimes to avoid "lifetime name `'a` shadows a

32
juniper_codegen/src/graphql_union/mod.rs
View file

@ -363,6 +363,8 @@ impl ToTokens for Definition {
self.impl_graphql_value_async_tokens().to_tokens(into);
self.impl_reflection_traits_tokens().to_tokens(into);
////////////////////////////////////////////////////////////////////////
self.impl_resolve_value().to_tokens(into);
gen::impl_resolvable(&self.behavior, self.ty_and_generics()).to_tokens(into);
self.impl_reflect().to_tokens(into);
}
}
@ -609,6 +611,36 @@ impl Definition {
}
}
/// Returns generated code implementing [`resolve::Value`] trait for this
/// [GraphQL union][0].
///
/// [`resolve::Value`]: juniper::resolve::Value
/// [0]: https://spec.graphql.org/October2021#sec-Unions
fn impl_resolve_value(&self) -> TokenStream {
let bh = &self.behavior;
let (ty, generics) = self.ty_and_generics();
let (inf, generics) = gen::mix_type_info(generics);
let (cx, generics) = gen::mix_context(generics);
let (sv, generics) = gen::mix_scalar_value(generics);
let (impl_gens, _, where_clause) = generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_gens ::juniper::resolve::Value<#inf, #cx, #sv, #bh>
for #ty #where_clause
{
fn resolve_value(
&self,
_: Option<&[::juniper::Selection<'_, #sv>]>,
_: &#inf,
_: &::juniper::Executor<'_, '_, #cx, #sv>,
) -> ::juniper::ExecutionResult<#sv> {
todo!()
}
}
}
}
/// Returns generated code implementing [`GraphQLValueAsync`] trait for this
/// [GraphQL union][1].
///