diff --git a/bluejay-core/src/definition/arguments_definition.rs b/bluejay-core/src/definition/arguments_definition.rs index e471115..2714343 100644 --- a/bluejay-core/src/definition/arguments_definition.rs +++ b/bluejay-core/src/definition/arguments_definition.rs @@ -1,10 +1,15 @@ -use crate::definition::InputValueDefinition; +use crate::definition::{InputValueDefinition, SchemaDefinition}; use crate::AsIter; -pub trait ArgumentsDefinition: AsIter { - type ArgumentDefinition: InputValueDefinition; +pub trait ArgumentsDefinition: + AsIter::InputValueDefinition> +{ + type SchemaDefinition: SchemaDefinition; - fn get(&self, name: &str) -> Option<&Self::ArgumentDefinition> { + fn get( + &self, + name: &str, + ) -> Option<&::InputValueDefinition> { self.iter().find(|fd| fd.name() == name) } } diff --git a/bluejay-core/src/definition/directive.rs b/bluejay-core/src/definition/directive.rs index a5daf7a..32a2822 100644 --- a/bluejay-core/src/definition/directive.rs +++ b/bluejay-core/src/definition/directive.rs @@ -1,14 +1,16 @@ -use crate::definition::{DirectiveDefinition, SchemaDefinition}; +use crate::definition::SchemaDefinition; pub trait Directive: crate::Directive { - type DirectiveDefinition: DirectiveDefinition; + type SchemaDefinition: SchemaDefinition; - fn definition<'a, S: SchemaDefinition>( + fn definition<'a>( &'a self, - schema_definition: &'a S, - ) -> &'a Self::DirectiveDefinition; + schema_definition: &'a Self::SchemaDefinition, + ) -> &'a ::DirectiveDefinition; } -pub trait Directives: crate::Directives::Directive> { - type Directive: Directive; +pub trait Directives: + crate::Directives::Directive> +{ + type SchemaDefinition: SchemaDefinition; } diff --git a/bluejay-core/src/definition/directive_definition.rs b/bluejay-core/src/definition/directive_definition.rs index 3ce5900..9bbb402 100644 --- a/bluejay-core/src/definition/directive_definition.rs +++ b/bluejay-core/src/definition/directive_definition.rs @@ -1,4 +1,4 @@ -use crate::definition::ArgumentsDefinition; +use crate::definition::SchemaDefinition; use crate::AsIter; use strum::{AsRefStr, Display, EnumIter, EnumString, VariantNames}; @@ -47,12 +47,14 @@ impl DirectiveLocation { } pub trait DirectiveDefinition { - type ArgumentsDefinition: ArgumentsDefinition; + type SchemaDefinition: SchemaDefinition; type DirectiveLocations: AsIter; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition>; + fn arguments_definition( + &self, + ) -> Option<&::ArgumentsDefinition>; fn is_repeatable(&self) -> bool; fn locations(&self) -> &Self::DirectiveLocations; fn is_builtin(&self) -> bool; diff --git a/bluejay-core/src/definition/enum_type_definition.rs b/bluejay-core/src/definition/enum_type_definition.rs index c4a4646..4d048c2 100644 --- a/bluejay-core/src/definition/enum_type_definition.rs +++ b/bluejay-core/src/definition/enum_type_definition.rs @@ -1,10 +1,14 @@ -use crate::definition::{EnumValueDefinitions, HasDirectives}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait EnumTypeDefinition: HasDirectives { - type EnumValueDefinitions: EnumValueDefinitions; +pub trait EnumTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn enum_value_definitions(&self) -> &Self::EnumValueDefinitions; + fn enum_value_definitions( + &self, + ) -> &::EnumValueDefinitions; fn is_builtin(&self) -> bool; } diff --git a/bluejay-core/src/definition/enum_value_definition.rs b/bluejay-core/src/definition/enum_value_definition.rs index ec907d2..e76e04e 100644 --- a/bluejay-core/src/definition/enum_value_definition.rs +++ b/bluejay-core/src/definition/enum_value_definition.rs @@ -1,6 +1,10 @@ -use crate::definition::HasDirectives; +use crate::definition::{HasDirectives, SchemaDefinition}; + +pub trait EnumValueDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; -pub trait EnumValueDefinition: HasDirectives { fn description(&self) -> Option<&str>; fn name(&self) -> &str; } diff --git a/bluejay-core/src/definition/enum_value_definitions.rs b/bluejay-core/src/definition/enum_value_definitions.rs index 590bdd7..4aaf4e9 100644 --- a/bluejay-core/src/definition/enum_value_definitions.rs +++ b/bluejay-core/src/definition/enum_value_definitions.rs @@ -1,6 +1,8 @@ -use crate::definition::EnumValueDefinition; +use crate::definition::SchemaDefinition; use crate::AsIter; -pub trait EnumValueDefinitions: AsIter { - type EnumValueDefinition: EnumValueDefinition; +pub trait EnumValueDefinitions: + AsIter::EnumValueDefinition> +{ + type SchemaDefinition: SchemaDefinition; } diff --git a/bluejay-core/src/definition/field_definition.rs b/bluejay-core/src/definition/field_definition.rs index 0e43884..e9319aa 100644 --- a/bluejay-core/src/definition/field_definition.rs +++ b/bluejay-core/src/definition/field_definition.rs @@ -1,12 +1,15 @@ -use crate::definition::{ArgumentsDefinition, HasDirectives, OutputType}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait FieldDefinition: HasDirectives { - type ArgumentsDefinition: ArgumentsDefinition; - type OutputType: OutputType; +pub trait FieldDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition>; - fn r#type(&self) -> &Self::OutputType; + fn arguments_definition( + &self, + ) -> Option<&::ArgumentsDefinition>; + fn r#type(&self) -> &::OutputType; fn is_builtin(&self) -> bool; } diff --git a/bluejay-core/src/definition/fields_definition.rs b/bluejay-core/src/definition/fields_definition.rs index 15d331f..08c233a 100644 --- a/bluejay-core/src/definition/fields_definition.rs +++ b/bluejay-core/src/definition/fields_definition.rs @@ -1,14 +1,19 @@ -use crate::definition::FieldDefinition; +use crate::definition::{FieldDefinition, SchemaDefinition}; use crate::AsIter; -pub trait FieldsDefinition: AsIter { - type FieldDefinition: FieldDefinition; +pub trait FieldsDefinition: + AsIter::FieldDefinition> +{ + type SchemaDefinition: SchemaDefinition; fn contains_field(&self, name: &str) -> bool { self.iter().any(|fd| fd.name() == name) } - fn get(&self, name: &str) -> Option<&Self::FieldDefinition> { + fn get( + &self, + name: &str, + ) -> Option<&::FieldDefinition> { self.iter().find(|fd| fd.name() == name) } } diff --git a/bluejay-core/src/definition/input_fields_definition.rs b/bluejay-core/src/definition/input_fields_definition.rs index f6da387..0b89965 100644 --- a/bluejay-core/src/definition/input_fields_definition.rs +++ b/bluejay-core/src/definition/input_fields_definition.rs @@ -1,10 +1,15 @@ -use crate::definition::InputValueDefinition; +use crate::definition::{InputValueDefinition, SchemaDefinition}; use crate::AsIter; -pub trait InputFieldsDefinition: AsIter { - type InputValueDefinition: InputValueDefinition; +pub trait InputFieldsDefinition: + AsIter::InputValueDefinition> +{ + type SchemaDefinition: SchemaDefinition; - fn get(&self, name: &str) -> Option<&Self::InputValueDefinition> { + fn get( + &self, + name: &str, + ) -> Option<&::InputValueDefinition> { self.iter().find(|fd| fd.name() == name) } } diff --git a/bluejay-core/src/definition/input_object_type_definition.rs b/bluejay-core/src/definition/input_object_type_definition.rs index 3a8622a..a73f68d 100644 --- a/bluejay-core/src/definition/input_object_type_definition.rs +++ b/bluejay-core/src/definition/input_object_type_definition.rs @@ -1,9 +1,13 @@ -use crate::definition::{HasDirectives, InputFieldsDefinition}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait InputObjectTypeDefinition: HasDirectives { - type InputFieldsDefinition: InputFieldsDefinition; +pub trait InputObjectTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn input_field_definitions(&self) -> &Self::InputFieldsDefinition; + fn input_field_definitions( + &self, + ) -> &::InputFieldsDefinition; } diff --git a/bluejay-core/src/definition/input_type.rs b/bluejay-core/src/definition/input_type.rs index 0d3cd9e..4cbc060 100644 --- a/bluejay-core/src/definition/input_type.rs +++ b/bluejay-core/src/definition/input_type.rs @@ -1,26 +1,26 @@ use crate::definition::{ EnumTypeDefinition, HasDirectives, InputObjectTypeDefinition, ScalarTypeDefinition, - SchemaDefinition, TypeDefinition, TypeDefinitionReference, + SchemaDefinition, TypeDefinitionReference, }; use crate::BuiltinScalarDefinition; #[derive(Debug)] -pub enum BaseInputTypeReference<'a, T: InputType> { +pub enum BaseInputTypeReference<'a, S: SchemaDefinition> { BuiltinScalar(BuiltinScalarDefinition), - CustomScalar(&'a T::CustomScalarTypeDefinition), - InputObject(&'a T::InputObjectTypeDefinition), - Enum(&'a T::EnumTypeDefinition), + CustomScalar(&'a S::CustomScalarTypeDefinition), + InputObject(&'a S::InputObjectTypeDefinition), + Enum(&'a S::EnumTypeDefinition), } -impl Clone for BaseInputTypeReference<'_, T> { +impl Clone for BaseInputTypeReference<'_, S> { fn clone(&self) -> Self { *self } } -impl Copy for BaseInputTypeReference<'_, T> {} +impl Copy for BaseInputTypeReference<'_, S> {} -impl<'a, T: InputType> BaseInputTypeReference<'a, T> { +impl<'a, S: SchemaDefinition> BaseInputTypeReference<'a, S> { pub fn name(&self) -> &'a str { match self { Self::BuiltinScalar(bstd) => bstd.name(), @@ -29,39 +29,22 @@ impl<'a, T: InputType> BaseInputTypeReference<'a, T> { Self::InputObject(iotd) => iotd.name(), } } - - pub fn convert< - I: InputType< - CustomScalarTypeDefinition = T::CustomScalarTypeDefinition, - InputObjectTypeDefinition = T::InputObjectTypeDefinition, - EnumTypeDefinition = T::EnumTypeDefinition, - >, - >( - &self, - ) -> BaseInputTypeReference<'a, I> { - match self { - Self::BuiltinScalar(bstd) => BaseInputTypeReference::BuiltinScalar(*bstd), - Self::CustomScalar(cstd) => BaseInputTypeReference::CustomScalar(*cstd), - Self::Enum(etd) => BaseInputTypeReference::Enum(*etd), - Self::InputObject(iotd) => BaseInputTypeReference::InputObject(*iotd), - } - } } -pub enum InputTypeReference<'a, I: InputType> { - Base(BaseInputTypeReference<'a, I>, bool), - List(&'a I, bool), +pub enum InputTypeReference<'a, S: SchemaDefinition> { + Base(BaseInputTypeReference<'a, S>, bool), + List(&'a S::InputType, bool), } -impl Clone for InputTypeReference<'_, I> { +impl Clone for InputTypeReference<'_, S> { fn clone(&self) -> Self { *self } } -impl Copy for InputTypeReference<'_, I> {} +impl Copy for InputTypeReference<'_, S> {} -impl<'a, I: InputType> InputTypeReference<'a, I> { +impl<'a, S: SchemaDefinition> InputTypeReference<'a, S> { pub fn is_required(&self) -> bool { match self { Self::Base(_, r) => *r, @@ -69,16 +52,7 @@ impl<'a, I: InputType> InputTypeReference<'a, I> { } } - pub fn base< - S: SchemaDefinition< - CustomScalarTypeDefinition = I::CustomScalarTypeDefinition, - InputObjectTypeDefinition = I::InputObjectTypeDefinition, - EnumTypeDefinition = I::EnumTypeDefinition, - >, - >( - &self, - schema_definition: &'a S, - ) -> BaseInputTypeReference<'a, I> { + pub fn base(&self, schema_definition: &'a S) -> BaseInputTypeReference<'a, S> { match self { Self::Base(b, _) => *b, Self::List(l, _) => l.base(schema_definition), @@ -94,12 +68,12 @@ impl<'a, I: InputType> InputTypeReference<'a, I> { } #[derive(Clone)] -pub enum ShallowInputTypeReference<'a, I: InputType> { +pub enum ShallowInputTypeReference<'a, S: SchemaDefinition> { Base(&'a str, bool), - List(&'a I, bool), + List(&'a S::InputType, bool), } -impl ShallowInputTypeReference<'_, I> { +impl ShallowInputTypeReference<'_, S> { pub fn is_required(&self) -> bool { match self { Self::Base(_, r) => *r, @@ -108,7 +82,7 @@ impl ShallowInputTypeReference<'_, I> { } } -impl std::fmt::Display for ShallowInputTypeReference<'_, I> { +impl std::fmt::Display for ShallowInputTypeReference<'_, S> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ShallowInputTypeReference::Base(name, required) => { @@ -126,7 +100,7 @@ impl std::fmt::Display for ShallowInputTypeReference<'_, I> { } } -impl PartialEq for ShallowInputTypeReference<'_, I> { +impl PartialEq for ShallowInputTypeReference<'_, S> { fn eq(&self, other: &Self) -> bool { match (self, other) { ( @@ -143,27 +117,14 @@ impl PartialEq for ShallowInputTypeReference<'_, I> { } pub trait InputType: Sized { - type CustomScalarTypeDefinition: ScalarTypeDefinition; - type InputObjectTypeDefinition: InputObjectTypeDefinition< - Directives = ::Directives, - >; - type EnumTypeDefinition: EnumTypeDefinition< - Directives = ::Directives, - >; - - fn as_ref< - 'a, - S: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - >( + type SchemaDefinition: SchemaDefinition; + + fn as_ref<'a>( &'a self, - schema_definition: &'a S, - ) -> InputTypeReference<'a, Self>; + schema_definition: &'a Self::SchemaDefinition, + ) -> InputTypeReference<'a, Self::SchemaDefinition>; - fn as_shallow_ref(&self) -> ShallowInputTypeReference<'_, Self>; + fn as_shallow_ref(&self) -> ShallowInputTypeReference<'_, Self::SchemaDefinition>; fn display_name(&self) -> String { self.as_shallow_ref().to_string() @@ -173,34 +134,20 @@ pub trait InputType: Sized { self.as_shallow_ref().is_required() } - fn base< - 'a, - S: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - >( + fn base<'a>( &'a self, - schema_definition: &'a S, - ) -> BaseInputTypeReference<'a, Self> { + schema_definition: &'a Self::SchemaDefinition, + ) -> BaseInputTypeReference<'a, Self::SchemaDefinition> { self.as_ref(schema_definition).base(schema_definition) } } -impl< - 'a, - T: TypeDefinition, - I: InputType< - CustomScalarTypeDefinition = T::CustomScalarTypeDefinition, - InputObjectTypeDefinition = T::InputObjectTypeDefinition, - EnumTypeDefinition = T::EnumTypeDefinition, - >, - > TryFrom> for BaseInputTypeReference<'a, I> +impl<'a, S: SchemaDefinition> TryFrom> + for BaseInputTypeReference<'a, S> { type Error = (); - fn try_from(value: TypeDefinitionReference<'a, T>) -> Result { + fn try_from(value: TypeDefinitionReference<'a, S>) -> Result { match value { TypeDefinitionReference::BuiltinScalar(bstd) => Ok(Self::BuiltinScalar(bstd)), TypeDefinitionReference::CustomScalar(cstd) => Ok(Self::CustomScalar(cstd)), @@ -213,8 +160,11 @@ impl< } } -impl<'a, I: InputType> HasDirectives for BaseInputTypeReference<'a, I> { - type Directives = ::Directives; +impl<'a, S: SchemaDefinition> HasDirectives for BaseInputTypeReference<'a, S> +where + ::Directives: 'a, +{ + type Directives = ::Directives; fn directives(&self) -> Option<&'a Self::Directives> { match self { diff --git a/bluejay-core/src/definition/input_value_definition.rs b/bluejay-core/src/definition/input_value_definition.rs index c63198e..91ab7a4 100644 --- a/bluejay-core/src/definition/input_value_definition.rs +++ b/bluejay-core/src/definition/input_value_definition.rs @@ -1,13 +1,15 @@ -use crate::definition::{HasDirectives, InputType}; +use crate::definition::{HasDirectives, InputType, SchemaDefinition}; use crate::ConstValue; -pub trait InputValueDefinition: HasDirectives { - type InputType: InputType; +pub trait InputValueDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; type Value: ConstValue; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn r#type(&self) -> &Self::InputType; + fn r#type(&self) -> &::InputType; fn default_value(&self) -> Option<&Self::Value>; fn is_required(&self) -> bool { diff --git a/bluejay-core/src/definition/interface_implementation.rs b/bluejay-core/src/definition/interface_implementation.rs index dbdeede..69786c1 100644 --- a/bluejay-core/src/definition/interface_implementation.rs +++ b/bluejay-core/src/definition/interface_implementation.rs @@ -1,12 +1,12 @@ -use crate::definition::{InterfaceTypeDefinition, SchemaDefinition}; +use crate::definition::SchemaDefinition; pub trait InterfaceImplementation { - type InterfaceTypeDefinition: InterfaceTypeDefinition; + type SchemaDefinition: SchemaDefinition; - fn interface<'a, S: SchemaDefinition>( + fn interface<'a>( &'a self, - schema_definition: &'a S, - ) -> &'a Self::InterfaceTypeDefinition; + schema_definition: &'a Self::SchemaDefinition, + ) -> &'a ::InterfaceTypeDefinition; fn name(&self) -> &str; } diff --git a/bluejay-core/src/definition/interface_implementations.rs b/bluejay-core/src/definition/interface_implementations.rs index df12e3b..6e81096 100644 --- a/bluejay-core/src/definition/interface_implementations.rs +++ b/bluejay-core/src/definition/interface_implementations.rs @@ -1,6 +1,8 @@ -use crate::definition::InterfaceImplementation; +use crate::definition::SchemaDefinition; use crate::AsIter; -pub trait InterfaceImplementations: AsIter { - type InterfaceImplementation: InterfaceImplementation; +pub trait InterfaceImplementations: + AsIter::InterfaceImplementation> +{ + type SchemaDefinition: SchemaDefinition; } diff --git a/bluejay-core/src/definition/interface_type_definition.rs b/bluejay-core/src/definition/interface_type_definition.rs index 568c211..b1c5fba 100644 --- a/bluejay-core/src/definition/interface_type_definition.rs +++ b/bluejay-core/src/definition/interface_type_definition.rs @@ -1,11 +1,14 @@ -use crate::definition::{FieldsDefinition, HasDirectives, InterfaceImplementations}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait InterfaceTypeDefinition: HasDirectives { - type FieldsDefinition: FieldsDefinition; - type InterfaceImplementations: InterfaceImplementations; +pub trait InterfaceTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations>; - fn fields_definition(&self) -> &Self::FieldsDefinition; + fn interface_implementations( + &self, + ) -> Option<&::InterfaceImplementations>; + fn fields_definition(&self) -> &::FieldsDefinition; } diff --git a/bluejay-core/src/definition/object_type_definition.rs b/bluejay-core/src/definition/object_type_definition.rs index d25be57..e59d329 100644 --- a/bluejay-core/src/definition/object_type_definition.rs +++ b/bluejay-core/src/definition/object_type_definition.rs @@ -1,12 +1,15 @@ -use crate::definition::{FieldsDefinition, HasDirectives, InterfaceImplementations}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait ObjectTypeDefinition: HasDirectives { - type FieldsDefinition: FieldsDefinition; - type InterfaceImplementations: InterfaceImplementations; +pub trait ObjectTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations>; - fn fields_definition(&self) -> &Self::FieldsDefinition; + fn interface_implementations( + &self, + ) -> Option<&::InterfaceImplementations>; + fn fields_definition(&self) -> &::FieldsDefinition; fn is_builtin(&self) -> bool; } diff --git a/bluejay-core/src/definition/output_type.rs b/bluejay-core/src/definition/output_type.rs index 33c5028..43aff3a 100644 --- a/bluejay-core/src/definition/output_type.rs +++ b/bluejay-core/src/definition/output_type.rs @@ -1,20 +1,20 @@ use crate::definition::{ EnumTypeDefinition, InterfaceTypeDefinition, ObjectTypeDefinition, ScalarTypeDefinition, - SchemaDefinition, TypeDefinition, TypeDefinitionReference, UnionTypeDefinition, + SchemaDefinition, TypeDefinitionReference, UnionTypeDefinition, }; use crate::BuiltinScalarDefinition; #[derive(Debug)] -pub enum BaseOutputTypeReference<'a, O: OutputType> { +pub enum BaseOutputTypeReference<'a, S: SchemaDefinition> { BuiltinScalar(BuiltinScalarDefinition), - CustomScalar(&'a O::CustomScalarTypeDefinition), - Enum(&'a O::EnumTypeDefinition), - Object(&'a O::ObjectTypeDefinition), - Interface(&'a O::InterfaceTypeDefinition), - Union(&'a O::UnionTypeDefinition), + CustomScalar(&'a S::CustomScalarTypeDefinition), + Enum(&'a S::EnumTypeDefinition), + Object(&'a S::ObjectTypeDefinition), + Interface(&'a S::InterfaceTypeDefinition), + Union(&'a S::UnionTypeDefinition), } -impl<'a, O: OutputType> BaseOutputTypeReference<'a, O> { +impl<'a, S: SchemaDefinition> BaseOutputTypeReference<'a, S> { pub fn name(&self) -> &'a str { match self { Self::BuiltinScalar(bstd) => bstd.name(), @@ -38,28 +38,28 @@ impl<'a, O: OutputType> BaseOutputTypeReference<'a, O> { } } -impl Clone for BaseOutputTypeReference<'_, O> { +impl Clone for BaseOutputTypeReference<'_, S> { fn clone(&self) -> Self { *self } } -impl Copy for BaseOutputTypeReference<'_, O> {} +impl Copy for BaseOutputTypeReference<'_, S> {} -pub enum OutputTypeReference<'a, O: OutputType> { - Base(BaseOutputTypeReference<'a, O>, bool), - List(&'a O, bool), +pub enum OutputTypeReference<'a, S: SchemaDefinition> { + Base(BaseOutputTypeReference<'a, S>, bool), + List(&'a S::OutputType, bool), } -impl Clone for OutputTypeReference<'_, O> { +impl Clone for OutputTypeReference<'_, S> { fn clone(&self) -> Self { *self } } -impl Copy for OutputTypeReference<'_, O> {} +impl Copy for OutputTypeReference<'_, S> {} -impl<'a, O: OutputType> OutputTypeReference<'a, O> { +impl<'a, S: SchemaDefinition> OutputTypeReference<'a, S> { pub fn is_required(&self) -> bool { match self { Self::Base(_, r) => *r, @@ -67,18 +67,7 @@ impl<'a, O: OutputType> OutputTypeReference<'a, O> { } } - pub fn base< - S: SchemaDefinition< - CustomScalarTypeDefinition = O::CustomScalarTypeDefinition, - EnumTypeDefinition = O::EnumTypeDefinition, - ObjectTypeDefinition = O::ObjectTypeDefinition, - InterfaceTypeDefinition = O::InterfaceTypeDefinition, - UnionTypeDefinition = O::UnionTypeDefinition, - >, - >( - &self, - schema_definition: &'a S, - ) -> BaseOutputTypeReference<'a, O> { + pub fn base(&self, schema_definition: &'a S) -> BaseOutputTypeReference<'a, S> { match self { Self::Base(b, _) => *b, Self::List(l, _) => l.base(schema_definition), @@ -87,12 +76,12 @@ impl<'a, O: OutputType> OutputTypeReference<'a, O> { } #[derive(Clone)] -pub enum ShallowOutputTypeReference<'a, O: OutputType> { +pub enum ShallowOutputTypeReference<'a, S: SchemaDefinition> { Base(&'a str, bool), - List(&'a O, bool), + List(&'a S::OutputType, bool), } -impl<'a, O: OutputType> ShallowOutputTypeReference<'a, O> { +impl<'a, S: SchemaDefinition> ShallowOutputTypeReference<'a, S> { pub fn is_required(&self) -> bool { match self { Self::Base(_, r) => *r, @@ -108,7 +97,7 @@ impl<'a, O: OutputType> ShallowOutputTypeReference<'a, O> { } } -impl PartialEq for ShallowOutputTypeReference<'_, O> { +impl PartialEq for ShallowOutputTypeReference<'_, S> { fn eq(&self, other: &Self) -> bool { match (self, other) { ( @@ -124,7 +113,7 @@ impl PartialEq for ShallowOutputTypeReference<'_, O> { } } -impl std::fmt::Display for ShallowOutputTypeReference<'_, O> { +impl std::fmt::Display for ShallowOutputTypeReference<'_, S> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ShallowOutputTypeReference::Base(name, required) => { @@ -143,27 +132,14 @@ impl std::fmt::Display for ShallowOutputTypeReference<'_, O> { } pub trait OutputType: Sized { - type CustomScalarTypeDefinition: ScalarTypeDefinition; - type EnumTypeDefinition: EnumTypeDefinition; - type ObjectTypeDefinition: ObjectTypeDefinition; - type InterfaceTypeDefinition: InterfaceTypeDefinition; - type UnionTypeDefinition: UnionTypeDefinition; - - fn as_ref< - 'a, - S: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - >, - >( + type SchemaDefinition: SchemaDefinition; + + fn as_ref<'a>( &'a self, - schema_definition: &'a S, - ) -> OutputTypeReference<'a, Self>; + schema_definition: &'a Self::SchemaDefinition, + ) -> OutputTypeReference<'a, Self::SchemaDefinition>; - fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self>; + fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self::SchemaDefinition>; fn display_name(&self) -> String { self.as_shallow_ref().to_string() @@ -177,38 +153,20 @@ pub trait OutputType: Sized { self.as_shallow_ref().base_name() } - fn base< - 'a, - S: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - >, - >( + fn base<'a>( &'a self, - schema_definition: &'a S, - ) -> BaseOutputTypeReference<'a, Self> { + schema_definition: &'a Self::SchemaDefinition, + ) -> BaseOutputTypeReference<'a, Self::SchemaDefinition> { self.as_ref(schema_definition).base(schema_definition) } } -impl< - 'a, - T: TypeDefinition, - O: OutputType< - CustomScalarTypeDefinition = T::CustomScalarTypeDefinition, - EnumTypeDefinition = T::EnumTypeDefinition, - ObjectTypeDefinition = T::ObjectTypeDefinition, - InterfaceTypeDefinition = T::InterfaceTypeDefinition, - UnionTypeDefinition = T::UnionTypeDefinition, - >, - > TryFrom> for BaseOutputTypeReference<'a, O> +impl<'a, S: SchemaDefinition> TryFrom> + for BaseOutputTypeReference<'a, S> { type Error = (); - fn try_from(value: TypeDefinitionReference<'a, T>) -> Result { + fn try_from(value: TypeDefinitionReference<'a, S>) -> Result { match value { TypeDefinitionReference::BuiltinScalar(bstd) => Ok(Self::BuiltinScalar(bstd)), TypeDefinitionReference::CustomScalar(cstd) => Ok(Self::CustomScalar(cstd)), diff --git a/bluejay-core/src/definition/scalar_type_definition.rs b/bluejay-core/src/definition/scalar_type_definition.rs index 67da4a7..11d2519 100644 --- a/bluejay-core/src/definition/scalar_type_definition.rs +++ b/bluejay-core/src/definition/scalar_type_definition.rs @@ -1,8 +1,12 @@ -use crate::definition::HasDirectives; +use crate::definition::{HasDirectives, SchemaDefinition}; use crate::Value; use std::borrow::Cow; -pub trait ScalarTypeDefinition: HasDirectives { +pub trait ScalarTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; + fn description(&self) -> Option<&str>; fn name(&self) -> &str; diff --git a/bluejay-core/src/definition/schema_definition.rs b/bluejay-core/src/definition/schema_definition.rs index 03d8e07..290b289 100644 --- a/bluejay-core/src/definition/schema_definition.rs +++ b/bluejay-core/src/definition/schema_definition.rs @@ -8,84 +8,32 @@ use crate::definition::{ }; pub trait SchemaDefinition: - HasDirectives::Directives> + Sized + HasDirectives::Directives> { - type Directive: Directive; - type Directives: Directives; - type InputValueDefinition: InputValueDefinition< - InputType = Self::InputType, - Directives = ::Directives, - >; - type InputFieldsDefinition: InputFieldsDefinition< - InputValueDefinition = Self::InputValueDefinition, - >; - type ArgumentsDefinition: ArgumentsDefinition; - type EnumValueDefinition: EnumValueDefinition< - Directives = ::Directives, - >; - type EnumValueDefinitions: EnumValueDefinitions; - type FieldDefinition: FieldDefinition< - ArgumentsDefinition = Self::ArgumentsDefinition, - OutputType = Self::OutputType, - Directives = ::Directives, - >; - type FieldsDefinition: FieldsDefinition; - type InterfaceImplementation: InterfaceImplementation< - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - >; - type InterfaceImplementations: InterfaceImplementations< - InterfaceImplementation = Self::InterfaceImplementation, - >; - type UnionMemberType: UnionMemberType; - type UnionMemberTypes: UnionMemberTypes; - type InputType: InputType< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >; - type OutputType: OutputType< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - >; - type CustomScalarTypeDefinition: ScalarTypeDefinition< - Directives = ::Directives, - >; - type ObjectTypeDefinition: ObjectTypeDefinition< - FieldsDefinition = Self::FieldsDefinition, - InterfaceImplementations = Self::InterfaceImplementations, - Directives = ::Directives, - >; - type InterfaceTypeDefinition: InterfaceTypeDefinition< - FieldsDefinition = Self::FieldsDefinition, - InterfaceImplementations = Self::InterfaceImplementations, - Directives = ::Directives, - >; - type UnionTypeDefinition: UnionTypeDefinition< - UnionMemberTypes = Self::UnionMemberTypes, - Directives = ::Directives, - FieldsDefinition = Self::FieldsDefinition, - >; - type InputObjectTypeDefinition: InputObjectTypeDefinition< - InputFieldsDefinition = Self::InputFieldsDefinition, - Directives = ::Directives, - >; - type EnumTypeDefinition: EnumTypeDefinition< - Directives = ::Directives, - EnumValueDefinitions = Self::EnumValueDefinitions, - >; - type TypeDefinition: TypeDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - >; - type DirectiveDefinition: DirectiveDefinition; - type TypeDefinitions<'a>: Iterator> + type Directive: Directive; + type Directives: Directives; + type InputValueDefinition: InputValueDefinition; + type InputFieldsDefinition: InputFieldsDefinition; + type ArgumentsDefinition: ArgumentsDefinition; + type EnumValueDefinition: EnumValueDefinition; + type EnumValueDefinitions: EnumValueDefinitions; + type FieldDefinition: FieldDefinition; + type FieldsDefinition: FieldsDefinition; + type InterfaceImplementation: InterfaceImplementation; + type InterfaceImplementations: InterfaceImplementations; + type UnionMemberType: UnionMemberType; + type UnionMemberTypes: UnionMemberTypes; + type InputType: InputType; + type OutputType: OutputType; + type CustomScalarTypeDefinition: ScalarTypeDefinition; + type ObjectTypeDefinition: ObjectTypeDefinition; + type InterfaceTypeDefinition: InterfaceTypeDefinition; + type UnionTypeDefinition: UnionTypeDefinition; + type InputObjectTypeDefinition: InputObjectTypeDefinition; + type EnumTypeDefinition: EnumTypeDefinition; + type TypeDefinition: TypeDefinition; + type DirectiveDefinition: DirectiveDefinition; + type TypeDefinitions<'a>: Iterator> where Self: 'a; type DirectiveDefinitions<'a>: Iterator @@ -99,10 +47,7 @@ pub trait SchemaDefinition: fn query(&self) -> &Self::ObjectTypeDefinition; fn mutation(&self) -> Option<&Self::ObjectTypeDefinition>; fn subscription(&self) -> Option<&Self::ObjectTypeDefinition>; - fn get_type_definition( - &self, - name: &str, - ) -> Option>; + fn get_type_definition(&self, name: &str) -> Option>; fn type_definitions(&self) -> Self::TypeDefinitions<'_>; fn get_directive_definition(&self, name: &str) -> Option<&Self::DirectiveDefinition>; fn directive_definitions(&self) -> Self::DirectiveDefinitions<'_>; diff --git a/bluejay-core/src/definition/type_definition.rs b/bluejay-core/src/definition/type_definition.rs index 865f700..6cdd7a9 100644 --- a/bluejay-core/src/definition/type_definition.rs +++ b/bluejay-core/src/definition/type_definition.rs @@ -1,33 +1,26 @@ use crate::definition::{ BaseInputTypeReference, BaseOutputTypeReference, EnumTypeDefinition, HasDirectives, - InputObjectTypeDefinition, InputType, InterfaceTypeDefinition, ObjectTypeDefinition, - OutputType, ScalarTypeDefinition, UnionTypeDefinition, + InputObjectTypeDefinition, InterfaceTypeDefinition, ObjectTypeDefinition, ScalarTypeDefinition, + SchemaDefinition, UnionTypeDefinition, }; use crate::BuiltinScalarDefinition; use enum_as_inner::EnumAsInner; #[derive(Debug, EnumAsInner)] -pub enum TypeDefinitionReference<'a, T: TypeDefinition> { +pub enum TypeDefinitionReference<'a, S: SchemaDefinition> { BuiltinScalar(BuiltinScalarDefinition), - CustomScalar(&'a T::CustomScalarTypeDefinition), - Object(&'a T::ObjectTypeDefinition), - InputObject(&'a T::InputObjectTypeDefinition), - Enum(&'a T::EnumTypeDefinition), - Union(&'a T::UnionTypeDefinition), - Interface(&'a T::InterfaceTypeDefinition), + CustomScalar(&'a S::CustomScalarTypeDefinition), + Object(&'a S::ObjectTypeDefinition), + InputObject(&'a S::InputObjectTypeDefinition), + Enum(&'a S::EnumTypeDefinition), + Union(&'a S::UnionTypeDefinition), + Interface(&'a S::InterfaceTypeDefinition), } -impl< - 'a, - T: TypeDefinition, - I: InputType< - CustomScalarTypeDefinition = T::CustomScalarTypeDefinition, - InputObjectTypeDefinition = T::InputObjectTypeDefinition, - EnumTypeDefinition = T::EnumTypeDefinition, - >, - > From> for TypeDefinitionReference<'a, T> +impl<'a, S: SchemaDefinition> From> + for TypeDefinitionReference<'a, S> { - fn from(value: BaseInputTypeReference<'a, I>) -> Self { + fn from(value: BaseInputTypeReference<'a, S>) -> Self { match value { BaseInputTypeReference::BuiltinScalar(bstd) => Self::BuiltinScalar(bstd), BaseInputTypeReference::CustomScalar(cstd) => Self::CustomScalar(cstd), @@ -37,19 +30,10 @@ impl< } } -impl< - 'a, - T: TypeDefinition, - O: OutputType< - CustomScalarTypeDefinition = T::CustomScalarTypeDefinition, - EnumTypeDefinition = T::EnumTypeDefinition, - ObjectTypeDefinition = T::ObjectTypeDefinition, - InterfaceTypeDefinition = T::InterfaceTypeDefinition, - UnionTypeDefinition = T::UnionTypeDefinition, - >, - > From> for TypeDefinitionReference<'a, T> +impl<'a, S: SchemaDefinition> From> + for TypeDefinitionReference<'a, S> { - fn from(value: BaseOutputTypeReference<'a, O>) -> Self { + fn from(value: BaseOutputTypeReference<'a, S>) -> Self { match value { BaseOutputTypeReference::BuiltinScalar(bstd) => Self::BuiltinScalar(bstd), BaseOutputTypeReference::CustomScalar(cstd) => Self::CustomScalar(cstd), @@ -62,37 +46,20 @@ impl< } pub trait TypeDefinition: Sized { - type CustomScalarTypeDefinition: ScalarTypeDefinition; - type ObjectTypeDefinition: ObjectTypeDefinition< - Directives = ::Directives, - >; - type InputObjectTypeDefinition: InputObjectTypeDefinition< - Directives = ::Directives, - >; - type EnumTypeDefinition: EnumTypeDefinition< - Directives = ::Directives, - >; - type UnionTypeDefinition: UnionTypeDefinition< - FieldsDefinition = ::FieldsDefinition, - Directives = ::Directives, - >; - type InterfaceTypeDefinition: InterfaceTypeDefinition< - FieldsDefinition = ::FieldsDefinition, - Directives = ::Directives, - >; - - fn as_ref(&self) -> TypeDefinitionReference<'_, Self>; + type SchemaDefinition: SchemaDefinition; + + fn as_ref(&self) -> TypeDefinitionReference<'_, Self::SchemaDefinition>; } -impl Clone for TypeDefinitionReference<'_, T> { +impl Clone for TypeDefinitionReference<'_, S> { fn clone(&self) -> Self { *self } } -impl Copy for TypeDefinitionReference<'_, T> {} +impl Copy for TypeDefinitionReference<'_, S> {} -impl<'a, T: TypeDefinition> TypeDefinitionReference<'a, T> { +impl<'a, S: SchemaDefinition> TypeDefinitionReference<'a, S> { pub fn name(&self) -> &'a str { match self { Self::BuiltinScalar(bsd) => bsd.name(), @@ -155,9 +122,7 @@ impl<'a, T: TypeDefinition> TypeDefinitionReference<'a, T> { ) } - pub fn fields_definition( - &self, - ) -> Option<&'a ::FieldsDefinition> { + pub fn fields_definition(&self) -> Option<&'a S::FieldsDefinition> { match self { Self::Object(otd) => Some(otd.fields_definition()), Self::Interface(itd) => Some(itd.fields_definition()), @@ -170,8 +135,11 @@ impl<'a, T: TypeDefinition> TypeDefinitionReference<'a, T> { } } -impl<'a, T: TypeDefinition> HasDirectives for TypeDefinitionReference<'a, T> { - type Directives = ::Directives; +impl<'a, S: SchemaDefinition> HasDirectives for TypeDefinitionReference<'a, S> +where + ::Directives: 'a, +{ + type Directives = ::Directives; fn directives(&self) -> Option<&'a Self::Directives> { match self { diff --git a/bluejay-core/src/definition/union_member_type.rs b/bluejay-core/src/definition/union_member_type.rs index 6d74ba9..9bb6a35 100644 --- a/bluejay-core/src/definition/union_member_type.rs +++ b/bluejay-core/src/definition/union_member_type.rs @@ -1,11 +1,11 @@ -use crate::definition::{ObjectTypeDefinition, SchemaDefinition}; +use crate::definition::SchemaDefinition; pub trait UnionMemberType { - type ObjectTypeDefinition: ObjectTypeDefinition; + type SchemaDefinition: SchemaDefinition; - fn member_type<'a, S: SchemaDefinition>( + fn member_type<'a>( &'a self, - schema_definition: &'a S, - ) -> &'a Self::ObjectTypeDefinition; + schema_definition: &'a Self::SchemaDefinition, + ) -> &'a ::ObjectTypeDefinition; fn name(&self) -> &str; } diff --git a/bluejay-core/src/definition/union_member_types.rs b/bluejay-core/src/definition/union_member_types.rs index ab0380e..f3242b9 100644 --- a/bluejay-core/src/definition/union_member_types.rs +++ b/bluejay-core/src/definition/union_member_types.rs @@ -1,14 +1,19 @@ -use crate::definition::UnionMemberType; +use crate::definition::{SchemaDefinition, UnionMemberType}; use crate::AsIter; -pub trait UnionMemberTypes: AsIter { - type UnionMemberType: UnionMemberType; +pub trait UnionMemberTypes: + AsIter::UnionMemberType> +{ + type SchemaDefinition: SchemaDefinition; fn contains_type(&self, name: &str) -> bool { self.iter().any(|t| t.name() == name) } - fn get(&self, name: &str) -> Option<&Self::UnionMemberType> { + fn get( + &self, + name: &str, + ) -> Option<&::UnionMemberType> { self.iter().find(|t| t.name() == name) } } diff --git a/bluejay-core/src/definition/union_type_definition.rs b/bluejay-core/src/definition/union_type_definition.rs index ab2e34f..c41d40b 100644 --- a/bluejay-core/src/definition/union_type_definition.rs +++ b/bluejay-core/src/definition/union_type_definition.rs @@ -1,12 +1,14 @@ -use crate::definition::{FieldsDefinition, HasDirectives, UnionMemberTypes}; +use crate::definition::{HasDirectives, SchemaDefinition}; -pub trait UnionTypeDefinition: HasDirectives { - type UnionMemberTypes: UnionMemberTypes; - type FieldsDefinition: FieldsDefinition; +pub trait UnionTypeDefinition: + HasDirectives::Directives> +{ + type SchemaDefinition: SchemaDefinition; fn description(&self) -> Option<&str>; fn name(&self) -> &str; - fn union_member_types(&self) -> &Self::UnionMemberTypes; + fn union_member_types(&self) + -> &::UnionMemberTypes; /// Should only contain the builtin `__typename` field definition - fn fields_definition(&self) -> &Self::FieldsDefinition; + fn fields_definition(&self) -> &::FieldsDefinition; } diff --git a/bluejay-parser/src/ast/definition/arguments_definition.rs b/bluejay-parser/src/ast/definition/arguments_definition.rs index ec86528..afd1e25 100644 --- a/bluejay-parser/src/ast/definition/arguments_definition.rs +++ b/bluejay-parser/src/ast/definition/arguments_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, InputValueDefinition}; +use crate::ast::definition::{Context, InputValueDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, IsMatch, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use crate::Span; @@ -24,7 +24,7 @@ impl<'a, C: Context> AsIter for ArgumentsDefinition<'a, C> { } impl<'a, C: Context> CoreArgumentsDefinition for ArgumentsDefinition<'a, C> { - type ArgumentDefinition = InputValueDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> FromTokens<'a> for ArgumentsDefinition<'a, C> { diff --git a/bluejay-parser/src/ast/definition/custom_scalar_type_definition.rs b/bluejay-parser/src/ast/definition/custom_scalar_type_definition.rs index 51f0caa..673b604 100644 --- a/bluejay-parser/src/ast/definition/custom_scalar_type_definition.rs +++ b/bluejay-parser/src/ast/definition/custom_scalar_type_definition.rs @@ -1,5 +1,5 @@ use crate::ast::{ - definition::{Context, Directives}, + definition::{Context, Directives, SchemaDefinition}, ConstDirectives, DepthLimiter, FromTokens, ParseError, Tokens, TryFromTokens, }; use crate::lexical_token::{Name, StringValue}; @@ -24,7 +24,9 @@ impl<'a, C: Context> CustomScalarTypeDefinition<'a, C> { } } -impl CoreScalarTypeDefinition for CustomScalarTypeDefinition<'_, C> { +impl<'a, C: Context> CoreScalarTypeDefinition for CustomScalarTypeDefinition<'a, C> { + type SchemaDefinition = SchemaDefinition<'a, C>; + fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) } diff --git a/bluejay-parser/src/ast/definition/directive.rs b/bluejay-parser/src/ast/definition/directive.rs index c66469e..37fdf85 100644 --- a/bluejay-parser/src/ast/definition/directive.rs +++ b/bluejay-parser/src/ast/definition/directive.rs @@ -1,9 +1,9 @@ use crate::ast::{ self, - definition::{Context, DirectiveDefinition}, + definition::{Context, DirectiveDefinition, SchemaDefinition}, }; use crate::{HasSpan, Span}; -use bluejay_core::definition::SchemaDefinition; +use bluejay_core::definition::SchemaDefinition as CoreSchemaDefinition; use std::marker::PhantomData; #[derive(Debug)] @@ -25,12 +25,12 @@ impl<'a, C: Context> bluejay_core::Directive for Directive<'a, C> { } impl<'a, C: Context> bluejay_core::definition::Directive for Directive<'a, C> { - type DirectiveDefinition = DirectiveDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn definition<'b, S: SchemaDefinition>( + fn definition<'b>( &'b self, - schema_definition: &'b S, - ) -> &'b Self::DirectiveDefinition { + schema_definition: &'b SchemaDefinition<'a, C>, + ) -> &'b DirectiveDefinition<'a, C> { schema_definition .get_directive_definition(self.inner.name().as_str()) .unwrap() @@ -74,7 +74,7 @@ impl<'a, C: Context> bluejay_core::Directives for Directives<'a, C> { } impl<'a, C: Context> bluejay_core::definition::Directives for Directives<'a, C> { - type Directive = Directive<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> From> for Directives<'a, C> { diff --git a/bluejay-parser/src/ast/definition/directive_definition.rs b/bluejay-parser/src/ast/definition/directive_definition.rs index f128ae8..6cef673 100644 --- a/bluejay-parser/src/ast/definition/directive_definition.rs +++ b/bluejay-parser/src/ast/definition/directive_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{ArgumentsDefinition, Context}; +use crate::ast::definition::{ArgumentsDefinition, Context, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, Parse, ParseError, Tokens, TryFromTokens}; use crate::lexical_token::{Name, PunctuatorType, StringValue}; use crate::Span; @@ -61,7 +61,7 @@ pub struct DirectiveDefinition<'a, C: Context> { } impl<'a, C: Context> CoreDirectiveDefinition for DirectiveDefinition<'a, C> { - type ArgumentsDefinition = ArgumentsDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; type DirectiveLocations = DirectiveLocations; fn description(&self) -> Option<&str> { @@ -72,7 +72,7 @@ impl<'a, C: Context> CoreDirectiveDefinition for DirectiveDefinition<'a, C> { self.name.as_ref() } - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition> { + fn arguments_definition(&self) -> Option<&ArgumentsDefinition<'a, C>> { self.arguments_definition.as_ref() } diff --git a/bluejay-parser/src/ast/definition/enum_type_definition.rs b/bluejay-parser/src/ast/definition/enum_type_definition.rs index 75ab74b..bb2cc77 100644 --- a/bluejay-parser/src/ast/definition/enum_type_definition.rs +++ b/bluejay-parser/src/ast/definition/enum_type_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, Directives, EnumValueDefinitions}; +use crate::ast::definition::{Context, Directives, EnumValueDefinitions, SchemaDefinition}; use crate::ast::{ ConstDirectives, DepthLimiter, FromTokens, Parse, ParseError, Tokens, TryFromTokens, }; @@ -15,7 +15,7 @@ pub struct EnumTypeDefinition<'a, C: Context> { } impl<'a, C: Context> CoreEnumTypeDefinition for EnumTypeDefinition<'a, C> { - type EnumValueDefinitions = EnumValueDefinitions<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -25,7 +25,7 @@ impl<'a, C: Context> CoreEnumTypeDefinition for EnumTypeDefinition<'a, C> { self.name.as_ref() } - fn enum_value_definitions(&self) -> &Self::EnumValueDefinitions { + fn enum_value_definitions(&self) -> &EnumValueDefinitions<'a, C> { &self.enum_value_definitions } diff --git a/bluejay-parser/src/ast/definition/enum_value_definition.rs b/bluejay-parser/src/ast/definition/enum_value_definition.rs index 5eec7e3..fe9bcc7 100644 --- a/bluejay-parser/src/ast/definition/enum_value_definition.rs +++ b/bluejay-parser/src/ast/definition/enum_value_definition.rs @@ -2,7 +2,7 @@ use crate::ast::DepthLimiter; use crate::lexical_token::{Name, StringValue}; use crate::{ ast::{ - definition::{Context, Directives}, + definition::{Context, Directives, SchemaDefinition}, ConstDirectives, FromTokens, ParseError, Tokens, TryFromTokens, }, HasSpan, @@ -22,7 +22,9 @@ impl<'a, C: Context> EnumValueDefinition<'a, C> { } } -impl CoreEnumValueDefinition for EnumValueDefinition<'_, C> { +impl<'a, C: Context> CoreEnumValueDefinition for EnumValueDefinition<'a, C> { + type SchemaDefinition = SchemaDefinition<'a, C>; + fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) } diff --git a/bluejay-parser/src/ast/definition/enum_value_definitions.rs b/bluejay-parser/src/ast/definition/enum_value_definitions.rs index 6a1140a..458c3ff 100644 --- a/bluejay-parser/src/ast/definition/enum_value_definitions.rs +++ b/bluejay-parser/src/ast/definition/enum_value_definitions.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, EnumValueDefinition}; +use crate::ast::definition::{Context, EnumValueDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use crate::Span; @@ -24,7 +24,7 @@ impl<'a, C: Context> AsIter for EnumValueDefinitions<'a, C> { } impl<'a, C: Context> CoreEnumValueDefinitions for EnumValueDefinitions<'a, C> { - type EnumValueDefinition = EnumValueDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> FromTokens<'a> for EnumValueDefinitions<'a, C> { diff --git a/bluejay-parser/src/ast/definition/field_definition.rs b/bluejay-parser/src/ast/definition/field_definition.rs index eceaa9d..7c220de 100644 --- a/bluejay-parser/src/ast/definition/field_definition.rs +++ b/bluejay-parser/src/ast/definition/field_definition.rs @@ -1,4 +1,6 @@ -use crate::ast::definition::{ArgumentsDefinition, Context, Directives, OutputType}; +use crate::ast::definition::{ + ArgumentsDefinition, Context, Directives, OutputType, SchemaDefinition, +}; use crate::ast::{ ConstDirectives, DepthLimiter, FromTokens, Parse, ParseError, Tokens, TryFromTokens, }; @@ -40,8 +42,7 @@ impl FieldDefinition<'_, C> { } impl<'a, C: Context> CoreFieldDefinition for FieldDefinition<'a, C> { - type ArgumentsDefinition = ArgumentsDefinition<'a, C>; - type OutputType = OutputType<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -51,11 +52,11 @@ impl<'a, C: Context> CoreFieldDefinition for FieldDefinition<'a, C> { self.name.as_ref() } - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition> { + fn arguments_definition(&self) -> Option<&ArgumentsDefinition<'a, C>> { self.arguments_definition.as_ref() } - fn r#type(&self) -> &Self::OutputType { + fn r#type(&self) -> &OutputType<'a, C> { &self.r#type } diff --git a/bluejay-parser/src/ast/definition/fields_definition.rs b/bluejay-parser/src/ast/definition/fields_definition.rs index e7b1a30..273a4e5 100644 --- a/bluejay-parser/src/ast/definition/fields_definition.rs +++ b/bluejay-parser/src/ast/definition/fields_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, FieldDefinition}; +use crate::ast::definition::{Context, FieldDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use crate::Span; @@ -24,7 +24,7 @@ impl<'a, C: Context> AsIter for FieldsDefinition<'a, C> { } impl<'a, C: Context> CoreFieldsDefinition for FieldsDefinition<'a, C> { - type FieldDefinition = FieldDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> FromTokens<'a> for FieldsDefinition<'a, C> { diff --git a/bluejay-parser/src/ast/definition/input_fields_definition.rs b/bluejay-parser/src/ast/definition/input_fields_definition.rs index af51c20..d7873c0 100644 --- a/bluejay-parser/src/ast/definition/input_fields_definition.rs +++ b/bluejay-parser/src/ast/definition/input_fields_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, InputValueDefinition}; +use crate::ast::definition::{Context, InputValueDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use crate::Span; @@ -24,7 +24,7 @@ impl<'a, C: Context> AsIter for InputFieldsDefinition<'a, C> { } impl<'a, C: Context> CoreInputFieldsDefinition for InputFieldsDefinition<'a, C> { - type InputValueDefinition = InputValueDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> FromTokens<'a> for InputFieldsDefinition<'a, C> { diff --git a/bluejay-parser/src/ast/definition/input_object_type_definition.rs b/bluejay-parser/src/ast/definition/input_object_type_definition.rs index 13569ef..94062f0 100644 --- a/bluejay-parser/src/ast/definition/input_object_type_definition.rs +++ b/bluejay-parser/src/ast/definition/input_object_type_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, Directives, InputFieldsDefinition}; +use crate::ast::definition::{Context, Directives, InputFieldsDefinition, SchemaDefinition}; use crate::ast::{ConstDirectives, DepthLimiter, FromTokens, ParseError, Tokens, TryFromTokens}; use crate::lexical_token::{Name, StringValue}; use bluejay_core::definition::{ @@ -14,7 +14,7 @@ pub struct InputObjectTypeDefinition<'a, C: Context> { } impl<'a, C: Context> CoreInputObjectTypeDefinition for InputObjectTypeDefinition<'a, C> { - type InputFieldsDefinition = InputFieldsDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -24,7 +24,7 @@ impl<'a, C: Context> CoreInputObjectTypeDefinition for InputObjectTypeDefinition self.name.as_ref() } - fn input_field_definitions(&self) -> &Self::InputFieldsDefinition { + fn input_field_definitions(&self) -> &InputFieldsDefinition<'a, C> { &self.input_fields_definition } } diff --git a/bluejay-parser/src/ast/definition/input_type.rs b/bluejay-parser/src/ast/definition/input_type.rs index 77096e8..025ad25 100644 --- a/bluejay-parser/src/ast/definition/input_type.rs +++ b/bluejay-parser/src/ast/definition/input_type.rs @@ -1,7 +1,4 @@ -use crate::ast::definition::{ - Context, CustomScalarTypeDefinition, DefaultContext, EnumTypeDefinition, - InputObjectTypeDefinition, TypeDefinition, -}; +use crate::ast::definition::{Context, DefaultContext, SchemaDefinition, TypeDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::{Name, PunctuatorType}; use crate::{HasSpan, Span}; @@ -25,7 +22,7 @@ impl<'a, C: Context + 'a> BaseInputType<'a, C> { pub(crate) fn core_type_from_type_definition( type_definition: &'a TypeDefinition<'a, C>, - ) -> Result>, ()> { + ) -> Result>, ()> { match type_definition { TypeDefinition::BuiltinScalar(bstd) => Ok(BaseInputTypeReference::BuiltinScalar(*bstd)), TypeDefinition::CustomScalar(cstd) => Ok(BaseInputTypeReference::CustomScalar(cstd)), @@ -54,21 +51,12 @@ impl<'a, C: Context> InputType<'a, C> { } impl<'a, C: Context + 'a> CoreInputType for InputType<'a, C> { - type CustomScalarTypeDefinition = CustomScalarTypeDefinition<'a, C>; - type EnumTypeDefinition = EnumTypeDefinition<'a, C>; - type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn as_ref< - 'b, - S: CoreSchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - >( + fn as_ref<'b>( &'b self, - schema_definition: &'b S, - ) -> InputTypeReference<'b, Self> { + schema_definition: &'b SchemaDefinition<'a, C>, + ) -> InputTypeReference<'b, SchemaDefinition<'a, C>> { match self { Self::Base(base, required, _) => InputTypeReference::Base( schema_definition @@ -84,12 +72,14 @@ impl<'a, C: Context + 'a> CoreInputType for InputType<'a, C> { } } - fn as_shallow_ref(&self) -> ShallowInputTypeReference<'_, Self> { + fn as_shallow_ref(&self) -> ShallowInputTypeReference<'_, Self::SchemaDefinition> { match self { Self::Base(base, required, _) => { ShallowInputTypeReference::Base(base.name().as_str(), *required) } - Self::List(inner, required, _) => ShallowInputTypeReference::List(inner, *required), + Self::List(inner, required, _) => { + ShallowInputTypeReference::List(inner.as_ref(), *required) + } } } } diff --git a/bluejay-parser/src/ast/definition/input_value_definition.rs b/bluejay-parser/src/ast/definition/input_value_definition.rs index 5a3e392..598b7b1 100644 --- a/bluejay-parser/src/ast/definition/input_value_definition.rs +++ b/bluejay-parser/src/ast/definition/input_value_definition.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, Directives, InputType}; +use crate::ast::definition::{Context, Directives, InputType, SchemaDefinition}; use crate::ast::{ConstDirectives, ConstValue, DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::{Name, PunctuatorType, StringValue}; use bluejay_core::definition::{HasDirectives, InputValueDefinition as CoreInputValueDefinition}; @@ -19,7 +19,7 @@ impl<'a, C: Context> InputValueDefinition<'a, C> { } impl<'a, C: Context> CoreInputValueDefinition for InputValueDefinition<'a, C> { - type InputType = InputType<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; type Value = ConstValue<'a>; fn description(&self) -> Option<&str> { @@ -30,7 +30,7 @@ impl<'a, C: Context> CoreInputValueDefinition for InputValueDefinition<'a, C> { self.name.as_ref() } - fn r#type(&self) -> &Self::InputType { + fn r#type(&self) -> &InputType<'a, C> { &self.r#type } diff --git a/bluejay-parser/src/ast/definition/interface_implementation.rs b/bluejay-parser/src/ast/definition/interface_implementation.rs index 3ed4be5..0a80484 100644 --- a/bluejay-parser/src/ast/definition/interface_implementation.rs +++ b/bluejay-parser/src/ast/definition/interface_implementation.rs @@ -1,6 +1,6 @@ use std::marker::PhantomData; -use crate::ast::definition::{Context, InterfaceTypeDefinition}; +use crate::ast::definition::{Context, InterfaceTypeDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::Name; use bluejay_core::definition::{ @@ -15,15 +15,12 @@ pub struct InterfaceImplementation<'a, C: Context + 'a> { } impl<'a, C: Context> CoreInterfaceImplementation for InterfaceImplementation<'a, C> { - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn interface< - 'b, - S: CoreSchemaDefinition, - >( + fn interface<'b>( &'b self, - schema_definition: &'b S, - ) -> &'b Self::InterfaceTypeDefinition { + schema_definition: &'b SchemaDefinition<'a, C>, + ) -> &'b InterfaceTypeDefinition<'a, C> { schema_definition .get_type_definition(self.interface_name().as_str()) .unwrap() diff --git a/bluejay-parser/src/ast/definition/interface_implementations.rs b/bluejay-parser/src/ast/definition/interface_implementations.rs index 330c341..bce1e8d 100644 --- a/bluejay-parser/src/ast/definition/interface_implementations.rs +++ b/bluejay-parser/src/ast/definition/interface_implementations.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, InterfaceImplementation}; +use crate::ast::definition::{Context, InterfaceImplementation, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, IsMatch, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use bluejay_core::definition::InterfaceImplementations as CoreInterfaceImplementations; @@ -22,7 +22,7 @@ impl<'a, C: Context + 'a> AsIter for InterfaceImplementations<'a, C> { } impl<'a, C: Context + 'a> CoreInterfaceImplementations for InterfaceImplementations<'a, C> { - type InterfaceImplementation = InterfaceImplementation<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context + 'a> InterfaceImplementations<'a, C> { diff --git a/bluejay-parser/src/ast/definition/interface_type_definition.rs b/bluejay-parser/src/ast/definition/interface_type_definition.rs index 8f63e6c..42f1635 100644 --- a/bluejay-parser/src/ast/definition/interface_type_definition.rs +++ b/bluejay-parser/src/ast/definition/interface_type_definition.rs @@ -1,4 +1,6 @@ -use crate::ast::definition::{Context, Directives, FieldsDefinition, InterfaceImplementations}; +use crate::ast::definition::{ + Context, Directives, FieldsDefinition, InterfaceImplementations, SchemaDefinition, +}; use crate::ast::{ConstDirectives, DepthLimiter, FromTokens, ParseError, Tokens, TryFromTokens}; use crate::lexical_token::{Name, StringValue}; use bluejay_core::definition::{ @@ -15,8 +17,7 @@ pub struct InterfaceTypeDefinition<'a, C: Context> { } impl<'a, C: Context> CoreInterfaceTypeDefinition for InterfaceTypeDefinition<'a, C> { - type FieldsDefinition = FieldsDefinition<'a, C>; - type InterfaceImplementations = InterfaceImplementations<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -26,11 +27,11 @@ impl<'a, C: Context> CoreInterfaceTypeDefinition for InterfaceTypeDefinition<'a, self.name.as_ref() } - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations> { + fn interface_implementations(&self) -> Option<&InterfaceImplementations<'a, C>> { self.interface_implementations.as_ref() } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, C> { &self.fields_definition } } diff --git a/bluejay-parser/src/ast/definition/object_type_definition.rs b/bluejay-parser/src/ast/definition/object_type_definition.rs index 931ec9c..4f56e9c 100644 --- a/bluejay-parser/src/ast/definition/object_type_definition.rs +++ b/bluejay-parser/src/ast/definition/object_type_definition.rs @@ -1,4 +1,6 @@ -use crate::ast::definition::{Context, Directives, FieldsDefinition, InterfaceImplementations}; +use crate::ast::definition::{ + Context, Directives, FieldsDefinition, InterfaceImplementations, SchemaDefinition, +}; use crate::ast::{ ConstDirectives, DepthLimiter, FromTokens, Parse, ParseError, Tokens, TryFromTokens, }; @@ -16,8 +18,7 @@ pub struct ObjectTypeDefinition<'a, C: Context> { } impl<'a, C: Context> CoreObjectTypeDefinition for ObjectTypeDefinition<'a, C> { - type FieldsDefinition = FieldsDefinition<'a, C>; - type InterfaceImplementations = InterfaceImplementations<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -27,11 +28,11 @@ impl<'a, C: Context> CoreObjectTypeDefinition for ObjectTypeDefinition<'a, C> { self.name.as_ref() } - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations> { + fn interface_implementations(&self) -> Option<&InterfaceImplementations<'a, C>> { self.interface_implementations.as_ref() } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, C> { &self.fields_definition } diff --git a/bluejay-parser/src/ast/definition/output_type.rs b/bluejay-parser/src/ast/definition/output_type.rs index e8d01a4..b72e0a8 100644 --- a/bluejay-parser/src/ast/definition/output_type.rs +++ b/bluejay-parser/src/ast/definition/output_type.rs @@ -1,7 +1,4 @@ -use crate::ast::definition::{ - Context, CustomScalarTypeDefinition, EnumTypeDefinition, InterfaceTypeDefinition, - ObjectTypeDefinition, TypeDefinition, UnionTypeDefinition, -}; +use crate::ast::definition::{Context, SchemaDefinition, TypeDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::{Name, PunctuatorType}; use crate::{HasSpan, Span}; @@ -31,7 +28,7 @@ impl<'a, C: Context + 'a> BaseOutputType<'a, C> { pub(crate) fn core_type_from_type_definition( type_definition: &'a TypeDefinition<'a, C>, - ) -> Result>, ()> { + ) -> Result>, ()> { match type_definition { TypeDefinition::BuiltinScalar(bstd) => { Ok(BaseOutputTypeReference::BuiltinScalar(*bstd)) @@ -62,25 +59,12 @@ impl<'a, C: Context + 'a> OutputType<'a, C> { } impl<'a, C: Context + 'a> CoreOutputType for OutputType<'a, C> { - type CustomScalarTypeDefinition = CustomScalarTypeDefinition<'a, C>; - type EnumTypeDefinition = EnumTypeDefinition<'a, C>; - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, C>; - type ObjectTypeDefinition = ObjectTypeDefinition<'a, C>; - type UnionTypeDefinition = UnionTypeDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn as_ref< - 'b, - S: CoreSchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - >, - >( + fn as_ref<'b>( &'b self, - schema_definition: &'b S, - ) -> OutputTypeReference<'b, Self> { + schema_definition: &'b SchemaDefinition<'a, C>, + ) -> OutputTypeReference<'b, SchemaDefinition<'a, C>> { match self { Self::Base(base, required, _) => OutputTypeReference::Base( schema_definition @@ -94,7 +78,7 @@ impl<'a, C: Context + 'a> CoreOutputType for OutputType<'a, C> { } } - fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self> { + fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self::SchemaDefinition> { match self { Self::Base(base, required, _) => { ShallowOutputTypeReference::Base(base.name().as_str(), *required) diff --git a/bluejay-parser/src/ast/definition/schema_definition.rs b/bluejay-parser/src/ast/definition/schema_definition.rs index 2c8d8d6..3df1957 100644 --- a/bluejay-parser/src/ast/definition/schema_definition.rs +++ b/bluejay-parser/src/ast/definition/schema_definition.rs @@ -103,7 +103,7 @@ impl<'a, C: Context> CoreSchemaDefinition for SchemaDefinition<'a, C> { type TypeDefinitions<'b> = std::iter::Map< Values<'b, &'b str, &'b TypeDefinition<'a, C>>, - fn(&&'b TypeDefinition<'a, C>) -> TypeDefinitionReference<'b, TypeDefinition<'a, C>>, + fn(&&'b TypeDefinition<'a, C>) -> TypeDefinitionReference<'b, SchemaDefinition<'a, C>>, > where 'a: 'b; @@ -139,13 +139,13 @@ impl<'a, C: Context> CoreSchemaDefinition for SchemaDefinition<'a, C> { fn get_type_definition( &self, name: &str, - ) -> Option> { + ) -> Option>> { self.type_definitions.get(name).map(|td| td.as_ref()) } fn type_definitions(&self) -> Self::TypeDefinitions<'_> { self.type_definitions.values().map( - |td: &&TypeDefinition| -> TypeDefinitionReference<'_, TypeDefinition<'a, C>> { + |td: &&TypeDefinition| -> TypeDefinitionReference<'_, SchemaDefinition<'a, C>> { td.as_ref() }, ) diff --git a/bluejay-parser/src/ast/definition/type_definition.rs b/bluejay-parser/src/ast/definition/type_definition.rs index 0e02f76..e31b45c 100644 --- a/bluejay-parser/src/ast/definition/type_definition.rs +++ b/bluejay-parser/src/ast/definition/type_definition.rs @@ -1,6 +1,6 @@ use crate::ast::definition::{ Context, CustomScalarTypeDefinition, EnumTypeDefinition, InputObjectTypeDefinition, - InterfaceTypeDefinition, ObjectTypeDefinition, UnionTypeDefinition, + InterfaceTypeDefinition, ObjectTypeDefinition, SchemaDefinition, UnionTypeDefinition, }; use crate::lexical_token::Name; use bluejay_core::definition::{TypeDefinition as CoreTypeDefinition, TypeDefinitionReference}; @@ -44,14 +44,9 @@ impl TypeDefinition<'_, C> { } impl<'a, C: Context> CoreTypeDefinition for TypeDefinition<'a, C> { - type CustomScalarTypeDefinition = CustomScalarTypeDefinition<'a, C>; - type ObjectTypeDefinition = ObjectTypeDefinition<'a, C>; - type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, C>; - type EnumTypeDefinition = EnumTypeDefinition<'a, C>; - type UnionTypeDefinition = UnionTypeDefinition<'a, C>; - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn as_ref(&self) -> TypeDefinitionReference<'_, Self> { + fn as_ref(&self) -> TypeDefinitionReference<'_, SchemaDefinition<'a, C>> { match self { Self::BuiltinScalar(bstd) => TypeDefinitionReference::BuiltinScalar(*bstd), Self::CustomScalar(cstd) => TypeDefinitionReference::CustomScalar(cstd), diff --git a/bluejay-parser/src/ast/definition/union_member_type.rs b/bluejay-parser/src/ast/definition/union_member_type.rs index 8cb4660..6828453 100644 --- a/bluejay-parser/src/ast/definition/union_member_type.rs +++ b/bluejay-parser/src/ast/definition/union_member_type.rs @@ -1,9 +1,11 @@ use std::marker::PhantomData; -use crate::ast::definition::{Context, ObjectTypeDefinition}; +use crate::ast::definition::{Context, ObjectTypeDefinition, SchemaDefinition}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::Name; -use bluejay_core::definition::{SchemaDefinition, UnionMemberType as CoreUnionMemberType}; +use bluejay_core::definition::{ + SchemaDefinition as CoreSchemaDefinition, UnionMemberType as CoreUnionMemberType, +}; #[derive(Debug)] pub struct UnionMemberType<'a, C: Context + 'a> { @@ -12,12 +14,12 @@ pub struct UnionMemberType<'a, C: Context + 'a> { } impl<'a, C: Context + 'a> CoreUnionMemberType for UnionMemberType<'a, C> { - type ObjectTypeDefinition = ObjectTypeDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; - fn member_type<'b, S: SchemaDefinition>( + fn member_type<'b>( &'b self, - schema_definition: &'b S, - ) -> &'b Self::ObjectTypeDefinition { + schema_definition: &'b SchemaDefinition<'a, C>, + ) -> &'b ObjectTypeDefinition<'a, C> { schema_definition .get_type_definition(self.name.as_str()) .unwrap() diff --git a/bluejay-parser/src/ast/definition/union_member_types.rs b/bluejay-parser/src/ast/definition/union_member_types.rs index a8eb975..a3b445f 100644 --- a/bluejay-parser/src/ast/definition/union_member_types.rs +++ b/bluejay-parser/src/ast/definition/union_member_types.rs @@ -1,4 +1,4 @@ -use crate::ast::definition::{Context, UnionMemberType}; +use crate::ast::definition::{Context, SchemaDefinition, UnionMemberType}; use crate::ast::{DepthLimiter, FromTokens, ParseError, Tokens}; use crate::lexical_token::PunctuatorType; use bluejay_core::definition::UnionMemberTypes as CoreUnionMemberTypes; @@ -22,7 +22,7 @@ impl<'a, C: Context> AsIter for UnionMemberTypes<'a, C> { } impl<'a, C: Context> CoreUnionMemberTypes for UnionMemberTypes<'a, C> { - type UnionMemberType = UnionMemberType<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; } impl<'a, C: Context> FromTokens<'a> for UnionMemberTypes<'a, C> { diff --git a/bluejay-parser/src/ast/definition/union_type_definition.rs b/bluejay-parser/src/ast/definition/union_type_definition.rs index 8aa1dee..ef9f270 100644 --- a/bluejay-parser/src/ast/definition/union_type_definition.rs +++ b/bluejay-parser/src/ast/definition/union_type_definition.rs @@ -1,4 +1,6 @@ -use crate::ast::definition::{Context, Directives, FieldsDefinition, UnionMemberTypes}; +use crate::ast::definition::{ + Context, Directives, FieldsDefinition, SchemaDefinition, UnionMemberTypes, +}; use crate::ast::{ConstDirectives, DepthLimiter, FromTokens, ParseError, Tokens, TryFromTokens}; use crate::lexical_token::{Name, PunctuatorType, StringValue}; use bluejay_core::definition::{HasDirectives, UnionTypeDefinition as CoreUnionTypeDefinition}; @@ -13,8 +15,7 @@ pub struct UnionTypeDefinition<'a, C: Context> { } impl<'a, C: Context> CoreUnionTypeDefinition for UnionTypeDefinition<'a, C> { - type UnionMemberTypes = UnionMemberTypes<'a, C>; - type FieldsDefinition = FieldsDefinition<'a, C>; + type SchemaDefinition = SchemaDefinition<'a, C>; fn description(&self) -> Option<&str> { self.description.as_ref().map(AsRef::as_ref) @@ -24,11 +25,11 @@ impl<'a, C: Context> CoreUnionTypeDefinition for UnionTypeDefinition<'a, C> { self.name.as_ref() } - fn union_member_types(&self) -> &Self::UnionMemberTypes { + fn union_member_types(&self) -> &UnionMemberTypes<'a, C> { &self.member_types } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, C> { &self.fields_definition } } diff --git a/bluejay-schema-comparator/src/changes.rs b/bluejay-schema-comparator/src/changes.rs index db84b70..36ba033 100644 --- a/bluejay-schema-comparator/src/changes.rs +++ b/bluejay-schema-comparator/src/changes.rs @@ -90,18 +90,18 @@ impl Criticality { #[derive(AsRefStr)] pub enum Change<'a, S: SchemaDefinition> { TypeRemoved { - removed_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + removed_type_definition: TypeDefinitionReference<'a, S>, }, TypeAdded { - added_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + added_type_definition: TypeDefinitionReference<'a, S>, }, TypeKindChanged { - old_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, - new_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + old_type_definition: TypeDefinitionReference<'a, S>, + new_type_definition: TypeDefinitionReference<'a, S>, }, TypeDescriptionChanged { - old_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, - new_type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + old_type_definition: TypeDefinitionReference<'a, S>, + new_type_definition: TypeDefinitionReference<'a, S>, }, FieldAdded { added_field_definition: &'a S::FieldDefinition, @@ -1295,8 +1295,8 @@ impl Change<'_, S> { } fn is_change_safe_for_field( - old_type: ShallowOutputTypeReference, - new_type: ShallowOutputTypeReference, + old_type: ShallowOutputTypeReference, + new_type: ShallowOutputTypeReference, ) -> bool { match (old_type, new_type) { ( @@ -1318,8 +1318,8 @@ fn is_change_safe_for_field( } fn is_change_safe_for_input_value( - old_type: ShallowInputTypeReference, - new_type: ShallowInputTypeReference, + old_type: ShallowInputTypeReference, + new_type: ShallowInputTypeReference, ) -> bool { match (old_type, new_type) { ( diff --git a/bluejay-schema-comparator/src/diff/schema.rs b/bluejay-schema-comparator/src/diff/schema.rs index 33ba999..f717d49 100644 --- a/bluejay-schema-comparator/src/diff/schema.rs +++ b/bluejay-schema-comparator/src/diff/schema.rs @@ -89,8 +89,8 @@ impl<'a, S: SchemaDefinition> SchemaDiff<'a, S> { fn changes_in_type( &self, - old_type: TypeDefinitionReference<'a, S::TypeDefinition>, - new_type: TypeDefinitionReference<'a, S::TypeDefinition>, + old_type: TypeDefinitionReference<'a, S>, + new_type: TypeDefinitionReference<'a, S>, changes: &mut Vec>, ) { match (old_type, new_type) { @@ -145,7 +145,7 @@ impl<'a, S: SchemaDefinition> SchemaDiff<'a, S> { } } - fn added_types(&self) -> impl Iterator> { + fn added_types(&self) -> impl Iterator> { self.new_schema_definition .type_definitions() .filter(|new_type| { diff --git a/bluejay-typegen-codegen/src/executable_definition/intermediate_representation.rs b/bluejay-typegen-codegen/src/executable_definition/intermediate_representation.rs index 725a282..d19c9d6 100644 --- a/bluejay-typegen-codegen/src/executable_definition/intermediate_representation.rs +++ b/bluejay-typegen-codegen/src/executable_definition/intermediate_representation.rs @@ -514,7 +514,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, C: CodeGenerator> fn build_field_type( &self, field: &'a E::Field, - output_type: OutputTypeReference<'a, S::OutputType>, + output_type: OutputTypeReference<'a, S>, depth: usize, path: Path<'a>, ) -> WrappedExecutableType<'a> { @@ -553,7 +553,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, C: CodeGenerator> &self, parent_name: &'a str, selection_set: Option<&'a E::SelectionSet>, - base_output_type: BaseOutputTypeReference<'a, S::OutputType>, + base_output_type: BaseOutputTypeReference<'a, S>, depth: usize, path: Path<'a>, ) -> ExecutableType<'a> { diff --git a/bluejay-typegen-codegen/src/input_object_type_definition.rs b/bluejay-typegen-codegen/src/input_object_type_definition.rs index 7d458ec..3949dfe 100644 --- a/bluejay-typegen-codegen/src/input_object_type_definition.rs +++ b/bluejay-typegen-codegen/src/input_object_type_definition.rs @@ -178,7 +178,7 @@ impl<'a, S: SchemaDefinition, C: CodeGenerator> InputObjectTypeDefinitionBuilder fn contains_non_list_reference( &self, target: &str, - ty: InputTypeReference<'a, S::InputType>, + ty: InputTypeReference<'a, S>, visited: &mut HashSet<&'a str>, ) -> bool { match ty { @@ -230,7 +230,7 @@ impl<'a, S: SchemaDefinition, C: CodeGenerator> InputObjectTypeDefinitionBuilder .any(|ivd| self.contains_reference_types(ivd.r#type(), visited)) } - fn type_for_base_input_type(&self, base: BaseInputTypeReference) -> syn::Type { + fn type_for_base_input_type(&self, base: BaseInputTypeReference) -> syn::Type { match base { BaseInputTypeReference::BuiltinScalar(bstd) => { builtin_scalar_type(bstd, self.config.borrow()) @@ -261,7 +261,7 @@ impl<'a, S: SchemaDefinition, C: CodeGenerator> InputObjectTypeDefinitionBuilder fn type_for_input_type( &self, - ty: InputTypeReference, + ty: InputTypeReference, parent_type_name: Option<&str>, has_default_value: Option, ) -> syn::Type { diff --git a/bluejay-typegen-codegen/src/validation/selections_are_valid.rs b/bluejay-typegen-codegen/src/validation/selections_are_valid.rs index 40bdd4b..91e21a7 100644 --- a/bluejay-typegen-codegen/src/validation/selections_are_valid.rs +++ b/bluejay-typegen-codegen/src/validation/selections_are_valid.rs @@ -34,7 +34,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - ty: TypeDefinitionReference<'a, S::TypeDefinition>, + ty: TypeDefinitionReference<'a, S>, ) { match ty { TypeDefinitionReference::Object(_) => self.visit_object_selection_set(selection_set), diff --git a/bluejay-validator/src/executable/cache.rs b/bluejay-validator/src/executable/cache.rs index 6bcea3f..e1a5d36 100644 --- a/bluejay-validator/src/executable/cache.rs +++ b/bluejay-validator/src/executable/cache.rs @@ -8,7 +8,7 @@ use std::collections::HashMap; pub struct Cache<'a, E: ExecutableDocument, S: SchemaDefinition> { variable_definition_input_types: - HashMap, VariableDefinitionInputType<'a, S::InputType>>, + HashMap, VariableDefinitionInputType<'a, S>>, indexed_fragment_definitions: HashMap<&'a str, &'a E::FragmentDefinition>, } @@ -52,7 +52,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Cache<'a, E, S> { pub fn variable_definition_input_type( &self, variable_type: &'a E::VariableType, - ) -> Option<&VariableDefinitionInputType<'a, S::InputType>> { + ) -> Option<&VariableDefinitionInputType<'a, S>> { self.variable_definition_input_types .get(&Indexed(variable_type)) } diff --git a/bluejay-validator/src/executable/document/error.rs b/bluejay-validator/src/executable/document/error.rs index 086f37a..6088b07 100644 --- a/bluejay-validator/src/executable/document/error.rs +++ b/bluejay-validator/src/executable/document/error.rs @@ -31,7 +31,7 @@ pub enum Error<'a, E: ExecutableDocument, S: SchemaDefinition> { }, FieldDoesNotExistOnType { field: &'a E::Field, - r#type: TypeDefinitionReference<'a, S::TypeDefinition>, + r#type: TypeDefinitionReference<'a, S>, }, OperationTypeNotDefined { operation: &'a E::ExplicitOperationDefinition, @@ -89,11 +89,11 @@ pub enum Error<'a, E: ExecutableDocument, S: SchemaDefinition> { }, FragmentSpreadIsNotPossible { fragment_spread: &'a E::FragmentSpread, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, }, InlineFragmentSpreadIsNotPossible { inline_fragment: &'a E::InlineFragment, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, }, InvalidConstValue(InputCoercionError<'a, true, E::Value>), InvalidVariableValue(InputCoercionError<'a, false, E::Value>), diff --git a/bluejay-validator/src/executable/document/orchestrator.rs b/bluejay-validator/src/executable/document/orchestrator.rs index 9a4d695..a1b3a08 100644 --- a/bluejay-validator/src/executable/document/orchestrator.rs +++ b/bluejay-validator/src/executable/document/orchestrator.rs @@ -117,7 +117,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, V: Visitor<'a, E, S>> fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { self.visitor.visit_selection_set(selection_set, scoped_type); @@ -234,7 +234,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, V: Visitor<'a, E, S>> fn visit_inline_fragment( &mut self, inline_fragment: &'a E::InlineFragment, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { if let Some(directives) = inline_fragment.directives() { @@ -258,7 +258,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, V: Visitor<'a, E, S>> fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { if let Some(directives) = fragment_spread.directives() { diff --git a/bluejay-validator/src/executable/document/rule.rs b/bluejay-validator/src/executable/document/rule.rs index aa2960f..f41ffa5 100644 --- a/bluejay-validator/src/executable/document/rule.rs +++ b/bluejay-validator/src/executable/document/rule.rs @@ -62,7 +62,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, R: Rule<'a, E, S>, ER> Visi fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - r#type: TypeDefinitionReference<'a, S::TypeDefinition>, + r#type: TypeDefinitionReference<'a, S>, ) { self.rule.visit_selection_set(selection_set, r#type); } @@ -119,7 +119,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, R: Rule<'a, E, S>, ER> Visi fn visit_inline_fragment( &mut self, inline_fragment: &'a E::InlineFragment, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, ) { self.rule .visit_inline_fragment(inline_fragment, scoped_type); @@ -128,7 +128,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, R: Rule<'a, E, S>, ER> Visi fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { self.rule diff --git a/bluejay-validator/src/executable/document/rules/all_variable_usages_allowed.rs b/bluejay-validator/src/executable/document/rules/all_variable_usages_allowed.rs index 4b88c86..34c4635 100644 --- a/bluejay-validator/src/executable/document/rules/all_variable_usages_allowed.rs +++ b/bluejay-validator/src/executable/document/rules/all_variable_usages_allowed.rs @@ -50,7 +50,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - _: TypeDefinitionReference<'a, S::TypeDefinition>, + _: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { if let Some(fragment_definition) = self.cache.fragment_definition(fragment_spread.name()) { @@ -187,7 +187,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> AllVariableUsagesAllowed<'a fn are_types_compatible( &self, variable_type: VariableTypeReference<'a, E::VariableType>, - location_type: InputTypeReference<'a, S::InputType>, + location_type: InputTypeReference<'a, S>, ) -> bool { match (variable_type, location_type) { ( diff --git a/bluejay-validator/src/executable/document/rules/all_variable_uses_defined.rs b/bluejay-validator/src/executable/document/rules/all_variable_uses_defined.rs index e044409..21c673d 100644 --- a/bluejay-validator/src/executable/document/rules/all_variable_uses_defined.rs +++ b/bluejay-validator/src/executable/document/rules/all_variable_uses_defined.rs @@ -40,7 +40,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - _: TypeDefinitionReference<'a, S::TypeDefinition>, + _: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { if let Some(fragment_definition) = self.cache.fragment_definition(fragment_spread.name()) { diff --git a/bluejay-validator/src/executable/document/rules/all_variables_used.rs b/bluejay-validator/src/executable/document/rules/all_variables_used.rs index ef9ac24..5be1963 100644 --- a/bluejay-validator/src/executable/document/rules/all_variables_used.rs +++ b/bluejay-validator/src/executable/document/rules/all_variables_used.rs @@ -41,7 +41,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - _: TypeDefinitionReference<'a, S::TypeDefinition>, + _: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { if let Some(fragment_definition) = self.cache.fragment_definition(fragment_spread.name()) { diff --git a/bluejay-validator/src/executable/document/rules/field_selection_merging.rs b/bluejay-validator/src/executable/document/rules/field_selection_merging.rs index 02374a2..0c899a1 100644 --- a/bluejay-validator/src/executable/document/rules/field_selection_merging.rs +++ b/bluejay-validator/src/executable/document/rules/field_selection_merging.rs @@ -34,7 +34,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition> Visitor<'a, E, S> fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - r#type: TypeDefinitionReference<'a, S::TypeDefinition>, + r#type: TypeDefinitionReference<'a, S>, ) { self.selection_set_valid(selection_set, r#type); } @@ -44,7 +44,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> FieldSelectionMer fn selection_set_valid( &mut self, selection_set: &'a E::SelectionSet, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, ) -> bool { if let Some(errors) = self.cached_errors.get(&Indexed(selection_set)) { errors.is_empty() @@ -233,7 +233,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> FieldSelectionMer fn selection_set_contained_fields( &mut self, selection_set: &'a E::SelectionSet, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, ) -> HashMap<&'a str, Vec>> { let mut fields = HashMap::new(); self.visit_selections_for_fields(selection_set.iter(), &mut fields, parent_type, &[]); @@ -272,7 +272,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> FieldSelectionMer &mut self, selections: impl Iterator, fields: &mut HashMap<&'a str, Vec>>, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, parent_fragments: &[&'a str], ) { selections.for_each(|selection| match selection.as_ref() { @@ -384,6 +384,6 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Rule<'a, E, S> struct FieldContext<'a, E: ExecutableDocument, S: SchemaDefinition> { field: &'a E::Field, field_definition: &'a S::FieldDefinition, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, parent_fragments: Vec<&'a str>, } diff --git a/bluejay-validator/src/executable/document/rules/field_selections.rs b/bluejay-validator/src/executable/document/rules/field_selections.rs index 6f610ba..503f75b 100644 --- a/bluejay-validator/src/executable/document/rules/field_selections.rs +++ b/bluejay-validator/src/executable/document/rules/field_selections.rs @@ -21,7 +21,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - r#type: TypeDefinitionReference<'a, S::TypeDefinition>, + r#type: TypeDefinitionReference<'a, S>, ) { if let Some(fields_definition) = r#type.fields_definition() { self.errors diff --git a/bluejay-validator/src/executable/document/rules/fragment_spread_is_possible.rs b/bluejay-validator/src/executable/document/rules/fragment_spread_is_possible.rs index 5b1e72d..a7acafa 100644 --- a/bluejay-validator/src/executable/document/rules/fragment_spread_is_possible.rs +++ b/bluejay-validator/src/executable/document/rules/fragment_spread_is_possible.rs @@ -31,7 +31,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a ::FragmentSpread, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, _path: &Path<'a, E>, ) { if let Some(fragment_definition) = self.cache.fragment_definition(fragment_spread.name()) { @@ -52,7 +52,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> fn visit_inline_fragment( &mut self, inline_fragment: &'a ::InlineFragment, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, ) { if let Some(type_condition) = inline_fragment.type_condition() { if let Some(fragment_type) = self.schema_definition.get_type_definition(type_condition) @@ -71,8 +71,8 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> impl<'a, E: ExecutableDocument, S: SchemaDefinition> FragmentSpreadIsPossible<'a, E, S> { fn spread_is_not_possible( &self, - parent_type: TypeDefinitionReference<'a, S::TypeDefinition>, - fragment_type: TypeDefinitionReference<'a, S::TypeDefinition>, + parent_type: TypeDefinitionReference<'a, S>, + fragment_type: TypeDefinitionReference<'a, S>, ) -> bool { // Fast path: if either type is not a composite type, spread is not applicable if !parent_type.is_composite() || !fragment_type.is_composite() { @@ -95,11 +95,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> FragmentSpreadIsPossible<'a !self.types_have_overlap(parent_type, fragment_type) } - fn type_contains_name( - &self, - t: TypeDefinitionReference<'a, S::TypeDefinition>, - name: &str, - ) -> bool { + fn type_contains_name(&self, t: TypeDefinitionReference<'a, S>, name: &str) -> bool { match t { TypeDefinitionReference::Object(_) => t.name() == name, TypeDefinitionReference::Interface(itd) => self @@ -116,8 +112,8 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> FragmentSpreadIsPossible<'a fn types_have_overlap( &self, - a: TypeDefinitionReference<'a, S::TypeDefinition>, - b: TypeDefinitionReference<'a, S::TypeDefinition>, + a: TypeDefinitionReference<'a, S>, + b: TypeDefinitionReference<'a, S>, ) -> bool { match (a, b) { (TypeDefinitionReference::Object(o), other) @@ -135,7 +131,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> FragmentSpreadIsPossible<'a fn possible_type_names( &self, - t: TypeDefinitionReference<'a, S::TypeDefinition>, + t: TypeDefinitionReference<'a, S>, ) -> impl Iterator + '_ { use itertools::Either; match t { diff --git a/bluejay-validator/src/executable/document/rules/fragment_spread_target_defined.rs b/bluejay-validator/src/executable/document/rules/fragment_spread_target_defined.rs index fb971f3..7a627d7 100644 --- a/bluejay-validator/src/executable/document/rules/fragment_spread_target_defined.rs +++ b/bluejay-validator/src/executable/document/rules/fragment_spread_target_defined.rs @@ -23,7 +23,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a ::FragmentSpread, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, _path: &Path<'a, E>, ) { if self diff --git a/bluejay-validator/src/executable/document/rules/fragment_spread_type_exists.rs b/bluejay-validator/src/executable/document/rules/fragment_spread_type_exists.rs index efddf53..a01ca13 100644 --- a/bluejay-validator/src/executable/document/rules/fragment_spread_type_exists.rs +++ b/bluejay-validator/src/executable/document/rules/fragment_spread_type_exists.rs @@ -39,7 +39,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_inline_fragment( &mut self, inline_fragment: &'a ::InlineFragment, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, ) { if let Some(type_condition) = inline_fragment.type_condition() { if self diff --git a/bluejay-validator/src/executable/document/rules/fragments_must_be_used.rs b/bluejay-validator/src/executable/document/rules/fragments_must_be_used.rs index 31be78b..60a80fe 100644 --- a/bluejay-validator/src/executable/document/rules/fragments_must_be_used.rs +++ b/bluejay-validator/src/executable/document/rules/fragments_must_be_used.rs @@ -26,7 +26,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition> Visitor<'a, E, S> fn visit_fragment_spread( &mut self, fragment_spread: &'a ::FragmentSpread, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, _path: &Path<'a, E>, ) { self.unused_fragment_definitions diff --git a/bluejay-validator/src/executable/document/rules/fragments_on_composite_types.rs b/bluejay-validator/src/executable/document/rules/fragments_on_composite_types.rs index 88582a2..5ba08d4 100644 --- a/bluejay-validator/src/executable/document/rules/fragments_on_composite_types.rs +++ b/bluejay-validator/src/executable/document/rules/fragments_on_composite_types.rs @@ -40,7 +40,7 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> fn visit_inline_fragment( &mut self, inline_fragment: &'a ::InlineFragment, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, ) { if let Some(type_condition) = inline_fragment.type_condition() { if matches!( diff --git a/bluejay-validator/src/executable/document/rules/value_is_valid.rs b/bluejay-validator/src/executable/document/rules/value_is_valid.rs index 9878869..52d6c8b 100644 --- a/bluejay-validator/src/executable/document/rules/value_is_valid.rs +++ b/bluejay-validator/src/executable/document/rules/value_is_valid.rs @@ -2,7 +2,7 @@ use crate::executable::{ document::{Error, Path, Rule, Visitor}, Cache, }; -use crate::value::input_coercion::CoerceInput; +use crate::value::input_coercion::{coerce_variable_definition_value, CoerceInput}; use bluejay_core::definition::{InputValueDefinition, SchemaDefinition}; use bluejay_core::executable::{ExecutableDocument, VariableDefinition}; use bluejay_core::Argument; @@ -33,7 +33,8 @@ impl<'a, E: ExecutableDocument + 'a, S: SchemaDefinition + 'a> Visitor<'a, E, S> .cache .variable_definition_input_type(variable_definition.r#type()) { - if let Err(coercion_errors) = self.schema_definition.coerce_value( + if let Err(coercion_errors) = coerce_variable_definition_value( + self.schema_definition, input_value_definition, default_value, Default::default(), diff --git a/bluejay-validator/src/executable/document/variable_definition_input_type.rs b/bluejay-validator/src/executable/document/variable_definition_input_type.rs index 4f00215..aa4a4f7 100644 --- a/bluejay-validator/src/executable/document/variable_definition_input_type.rs +++ b/bluejay-validator/src/executable/document/variable_definition_input_type.rs @@ -1,48 +1,14 @@ -use bluejay_core::definition::{ - BaseInputTypeReference, InputType, InputTypeReference, SchemaDefinition, - ShallowInputTypeReference, -}; +use bluejay_core::definition::{BaseInputTypeReference, SchemaDefinition}; use bluejay_core::executable::{VariableType, VariableTypeReference}; #[derive(Clone)] -pub enum VariableDefinitionInputType<'a, I: InputType> { - Base(BaseInputTypeReference<'a, I>, bool), +pub enum VariableDefinitionInputType<'a, S: SchemaDefinition> { + Base(BaseInputTypeReference<'a, S>, bool), List(Box, bool), } -impl InputType for VariableDefinitionInputType<'_, I> { - type CustomScalarTypeDefinition = I::CustomScalarTypeDefinition; - type EnumTypeDefinition = I::EnumTypeDefinition; - type InputObjectTypeDefinition = I::InputObjectTypeDefinition; - - fn as_ref< - S: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - >( - &self, - _: &S, - ) -> InputTypeReference<'_, Self> { - match self { - Self::Base(base, required) => { - InputTypeReference::Base(base.convert::(), *required) - } - Self::List(inner, required) => InputTypeReference::List(inner.as_ref(), *required), - } - } - - fn as_shallow_ref(&self) -> ShallowInputTypeReference<'_, Self> { - match self { - Self::Base(base, required) => ShallowInputTypeReference::Base(base.name(), *required), - Self::List(inner, required) => ShallowInputTypeReference::List(inner, *required), - } - } -} - impl<'a, S: SchemaDefinition, T: VariableType> TryFrom<(&'a S, &T)> - for VariableDefinitionInputType<'a, S::InputType> + for VariableDefinitionInputType<'a, S> { type Error = (); @@ -55,13 +21,13 @@ impl<'a, S: SchemaDefinition, T: VariableType> TryFrom<(&'a S, &T)> } } -impl<'a, I: InputType, T: VariableType> TryFrom<(BaseInputTypeReference<'a, I>, &T)> - for VariableDefinitionInputType<'a, I> +impl<'a, S: SchemaDefinition, T: VariableType> TryFrom<(BaseInputTypeReference<'a, S>, &T)> + for VariableDefinitionInputType<'a, S> { type Error = (); fn try_from( - (base, variable_type): (BaseInputTypeReference<'a, I>, &T), + (base, variable_type): (BaseInputTypeReference<'a, S>, &T), ) -> Result { match variable_type.as_ref() { VariableTypeReference::Named(_, required) => { diff --git a/bluejay-validator/src/executable/document/visitor.rs b/bluejay-validator/src/executable/document/visitor.rs index 54465b2..efff665 100644 --- a/bluejay-validator/src/executable/document/visitor.rs +++ b/bluejay-validator/src/executable/document/visitor.rs @@ -14,7 +14,7 @@ pub trait Visitor<'a, E: ExecutableDocument, S: SchemaDefinition> { fn visit_selection_set( &mut self, _selection_set: &'a E::SelectionSet, - _type: TypeDefinitionReference<'a, S::TypeDefinition>, + _type: TypeDefinitionReference<'a, S>, ) { } @@ -61,14 +61,14 @@ pub trait Visitor<'a, E: ExecutableDocument, S: SchemaDefinition> { fn visit_inline_fragment( &mut self, _inline_fragment: &'a E::InlineFragment, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, ) { } fn visit_fragment_spread( &mut self, _fragment_spread: &'a E::FragmentSpread, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, _path: &Path<'a, E>, ) { } @@ -119,7 +119,7 @@ macro_rules! impl_visitor { fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - r#type: TypeDefinitionReference<'a, S::TypeDefinition>, + r#type: TypeDefinitionReference<'a, S>, ) { #(self.N.visit_selection_set(selection_set, r#type);)* } @@ -180,7 +180,7 @@ macro_rules! impl_visitor { fn visit_inline_fragment( &mut self, inline_fragment: &'a E::InlineFragment, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, ) { #(self.N.visit_inline_fragment(inline_fragment, scoped_type);)* } @@ -188,7 +188,7 @@ macro_rules! impl_visitor { fn visit_fragment_spread( &mut self, fragment_spread: &'a E::FragmentSpread, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, path: &Path<'a, E>, ) { #(self.N.visit_fragment_spread(fragment_spread, scoped_type, path);)* diff --git a/bluejay-validator/src/executable/operation/analyzers/complexity_cost.rs b/bluejay-validator/src/executable/operation/analyzers/complexity_cost.rs index b62b88a..529706b 100644 --- a/bluejay-validator/src/executable/operation/analyzers/complexity_cost.rs +++ b/bluejay-validator/src/executable/operation/analyzers/complexity_cost.rs @@ -3,8 +3,8 @@ use crate::executable::{ Cache, }; use bluejay_core::definition::{ - FieldDefinition, ObjectTypeDefinition, OutputType, SchemaDefinition, TypeDefinition, - TypeDefinitionReference, UnionMemberType, UnionTypeDefinition, + FieldDefinition, ObjectTypeDefinition, OutputType, SchemaDefinition, TypeDefinitionReference, + UnionMemberType, UnionTypeDefinition, }; use bluejay_core::executable::{ExecutableDocument, Field}; use bluejay_core::AsIter; @@ -30,7 +30,7 @@ pub struct ComplexityCost< > { schema_definition: &'a S, cost_computer: C, - scopes_arena: Arena>, + scopes_arena: Arena>, scopes_stack: Vec>, } @@ -64,7 +64,7 @@ impl< &mut self, field: &'a ::Field, field_definition: &'a S::FieldDefinition, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { if !included { @@ -149,7 +149,7 @@ impl< &mut self, _field: &'a ::Field, _field_definition: &'a S::FieldDefinition, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { if included { @@ -194,7 +194,7 @@ impl< fn merged_max_complexity_for_scopes( &self, - scopes: &[&ComplexityScope<'a, S::TypeDefinition, C::FieldMultipliers>], + scopes: &[&ComplexityScope<'a, S, C::FieldMultipliers>], ) -> usize { // build a set of all unique possible type definitions // with abstract types expanded to encompass all of their possible types @@ -273,7 +273,7 @@ impl< } }) }) - .collect::>>(); + .collect::>>(); let children_cost = self.merged_max_complexity_for_scopes(&composite_scopes); @@ -284,7 +284,7 @@ impl< fn possible_type_names( &self, - ty: &TypeDefinitionReference<'a, S::TypeDefinition>, + ty: &TypeDefinitionReference<'a, S>, ) -> impl Iterator { match ty { TypeDefinitionReference::Object(_) => Either::Left(Some(ty.name()).into_iter()), @@ -305,19 +305,19 @@ impl< type InnerSelection<'a> = HashMap<&'a str, NodeId>; -struct TypedSelection<'a, T: TypeDefinition> { - type_definition: TypeDefinitionReference<'a, T>, +struct TypedSelection<'a, S: SchemaDefinition> { + type_definition: TypeDefinitionReference<'a, S>, inner_selection: InnerSelection<'a>, } -struct ComplexityScope<'a, T: TypeDefinition, F> { +struct ComplexityScope<'a, S: SchemaDefinition, F> { cost: usize, multiplier: usize, - typed_selections: HashMap<&'a str, TypedSelection<'a, T>>, + typed_selections: HashMap<&'a str, TypedSelection<'a, S>>, field_multipliers: F, } -impl Default for ComplexityScope<'_, T, F> { +impl Default for ComplexityScope<'_, S, F> { fn default() -> Self { Self { cost: 0, @@ -328,7 +328,7 @@ impl Default for ComplexityScope<'_, T, F> { } } -impl ComplexityScope<'_, T, F> { +impl ComplexityScope<'_, S, F> { fn multiplier_for_field(&self, field: &E::Field) -> usize where F: FieldMultipliers, diff --git a/bluejay-validator/src/executable/operation/analyzers/deprecation.rs b/bluejay-validator/src/executable/operation/analyzers/deprecation.rs index 3ab84e3..4fdfa26 100644 --- a/bluejay-validator/src/executable/operation/analyzers/deprecation.rs +++ b/bluejay-validator/src/executable/operation/analyzers/deprecation.rs @@ -2,10 +2,12 @@ use crate::executable::{ operation::{Analyzer, VariableValues, Visitor}, Cache, }; +use crate::value::input_type::{ + InputTypeView, InputTypeViewReference, SchemaInputTypeView, VariableDefinitionInputTypeView, +}; use bluejay_core::definition::{ BaseInputTypeReference, EnumTypeDefinition, EnumValueDefinition, HasDirectives, - InputObjectTypeDefinition, InputType, InputTypeReference, InputValueDefinition, - SchemaDefinition, + InputObjectTypeDefinition, InputValueDefinition, SchemaDefinition, }; use bluejay_core::executable::{ExecutableDocument, Field, VariableDefinition}; use bluejay_core::{Argument, AsIter, Directive, ObjectValue, Value, ValueReference}; @@ -72,11 +74,15 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor .variable_values .get(variable_definition.variable().as_ref()) { - self.find_deprecations_for_value(input_type, value, variable_definition.variable()); + self.find_deprecations_for_value( + VariableDefinitionInputTypeView::new(input_type), + value, + variable_definition.variable(), + ); } if let Some(default_value) = variable_definition.default_value() { self.find_deprecations_for_value( - input_type, + VariableDefinitionInputTypeView::new(input_type), default_value, variable_definition.variable(), ); @@ -88,10 +94,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor &mut self, field: &'a ::Field, field_definition: &'a ::FieldDefinition, - _scoped_type: bluejay_core::definition::TypeDefinitionReference< - 'a, - ::TypeDefinition, - >, + _scoped_type: bluejay_core::definition::TypeDefinitionReference<'a, S>, included: bool, ) { if !included { @@ -125,7 +128,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor } self.find_deprecations_for_value( - input_value_definition.r#type(), + SchemaInputTypeView::new(input_value_definition.r#type()), argument.value(), argument.name(), ); @@ -161,26 +164,22 @@ fn get_deprecation_reason(ast_item: &N) -> Option<&str> { impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Deprecation<'a, E, S, VV> { fn find_deprecations_for_value< const CONST: bool, - I: InputType< - CustomScalarTypeDefinition = S::CustomScalarTypeDefinition, - InputObjectTypeDefinition = S::InputObjectTypeDefinition, - EnumTypeDefinition = S::EnumTypeDefinition, - >, + I: InputTypeView<'a, SchemaDefinition = S>, V: Value, >( &mut self, - input_type: &'a I, + input_type: I, value: &'a V, name: &'a str, ) { match input_type.as_ref(self.schema_definition) { - InputTypeReference::List(inner_list_type, _) => match value.as_ref() { + InputTypeViewReference::List(inner_list_type, _) => match value.as_ref() { ValueReference::List(list_value) => list_value.iter().for_each(|list_item| { self.find_deprecations_for_value(inner_list_type, list_item, name) }), _ => self.find_deprecations_for_value(inner_list_type, value, name), }, - InputTypeReference::Base(base_input_type, _) => match base_input_type { + InputTypeViewReference::Base(base_input_type, _) => match base_input_type { BaseInputTypeReference::Enum(etd) => { let enum_value = match value.as_ref() { ValueReference::Enum(enum_value) => Some(enum_value), @@ -231,7 +230,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Depreca } self.find_deprecations_for_value( - input_field_definition.r#type(), + SchemaInputTypeView::new(input_field_definition.r#type()), value, name, ) diff --git a/bluejay-validator/src/executable/operation/analyzers/query_depth.rs b/bluejay-validator/src/executable/operation/analyzers/query_depth.rs index 80f99a3..ca05664 100644 --- a/bluejay-validator/src/executable/operation/analyzers/query_depth.rs +++ b/bluejay-validator/src/executable/operation/analyzers/query_depth.rs @@ -33,7 +33,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor &mut self, _field: &'a ::Field, _field_definition: &'a S::FieldDefinition, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { if included { @@ -46,7 +46,7 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor &mut self, _field: &'a ::Field, _field_definition: &'a S::FieldDefinition, - _scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + _scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { if included { diff --git a/bluejay-validator/src/executable/operation/analyzers/variable_values_are_valid.rs b/bluejay-validator/src/executable/operation/analyzers/variable_values_are_valid.rs index c89dbdd..5bcbcda 100644 --- a/bluejay-validator/src/executable/operation/analyzers/variable_values_are_valid.rs +++ b/bluejay-validator/src/executable/operation/analyzers/variable_values_are_valid.rs @@ -6,7 +6,7 @@ use crate::{ operation::{Analyzer, VariableValues, Visitor}, Cache, }, - value::input_coercion::{CoerceInput, Error as CoerceInputError}, + value::input_coercion::{coerce_variable_definition_value, Error as CoerceInputError}, }; use bluejay_core::definition::SchemaDefinition; use bluejay_core::executable::{ExecutableDocument, VariableDefinition}; @@ -63,7 +63,8 @@ impl<'a, E: ExecutableDocument, S: SchemaDefinition, VV: VariableValues> Visitor }; match key_and_value { Some((_, value)) => { - if let Err(errors) = self.schema_definition.coerce_const_value( + if let Err(errors) = coerce_variable_definition_value( + self.schema_definition, variable_definition_input_type, value, Default::default(), diff --git a/bluejay-validator/src/executable/operation/orchestrator.rs b/bluejay-validator/src/executable/operation/orchestrator.rs index d54d369..c28d5d8 100644 --- a/bluejay-validator/src/executable/operation/orchestrator.rs +++ b/bluejay-validator/src/executable/operation/orchestrator.rs @@ -149,7 +149,7 @@ impl< fn visit_selection_set( &mut self, selection_set: &'a E::SelectionSet, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { selection_set @@ -175,7 +175,7 @@ impl< &mut self, field: &'a E::Field, field_definition: &'a S::FieldDefinition, - owner_type: TypeDefinitionReference<'a, S::TypeDefinition>, + owner_type: TypeDefinitionReference<'a, S>, included: bool, ) { if let Some(directives) = field.directives() { @@ -236,7 +236,7 @@ impl< fn visit_inline_fragment( &mut self, inline_fragment: &'a E::InlineFragment, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { if let Some(directives) = inline_fragment.directives() { diff --git a/bluejay-validator/src/executable/operation/visitor.rs b/bluejay-validator/src/executable/operation/visitor.rs index 27df99a..9c8296f 100644 --- a/bluejay-validator/src/executable/operation/visitor.rs +++ b/bluejay-validator/src/executable/operation/visitor.rs @@ -34,7 +34,7 @@ pub trait Visitor<'a, E: ExecutableDocument, S: SchemaDefinition, V: VariableVal &mut self, field: &'a E::Field, field_definition: &'a S::FieldDefinition, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { } @@ -46,7 +46,7 @@ pub trait Visitor<'a, E: ExecutableDocument, S: SchemaDefinition, V: VariableVal &mut self, field: &'a ::Field, field_definition: &'a S::FieldDefinition, - scoped_type: TypeDefinitionReference<'a, S::TypeDefinition>, + scoped_type: TypeDefinitionReference<'a, S>, included: bool, ) { } @@ -88,7 +88,7 @@ macro_rules! impl_visitor { &mut self, field: &'a E::Field, field_definition: &'a S::FieldDefinition, - owner_type: TypeDefinitionReference<'a, S::TypeDefinition>, + owner_type: TypeDefinitionReference<'a, S>, included: bool, ) { #(self.N.visit_field(field, field_definition, owner_type, included);)* @@ -98,7 +98,7 @@ macro_rules! impl_visitor { &mut self, field: &'a ::Field, field_definition: &'a S::FieldDefinition, - owner_type: TypeDefinitionReference<'a, S::TypeDefinition>, + owner_type: TypeDefinitionReference<'a, S>, included: bool, ) { #(self.N.leave_field(field, field_definition, owner_type, included);)* diff --git a/bluejay-validator/src/value.rs b/bluejay-validator/src/value.rs index 6d3bfe5..f822818 100644 --- a/bluejay-validator/src/value.rs +++ b/bluejay-validator/src/value.rs @@ -1 +1,2 @@ pub mod input_coercion; +pub(crate) mod input_type; diff --git a/bluejay-validator/src/value/input_coercion.rs b/bluejay-validator/src/value/input_coercion.rs index db9946d..5313125 100644 --- a/bluejay-validator/src/value/input_coercion.rs +++ b/bluejay-validator/src/value/input_coercion.rs @@ -1,8 +1,12 @@ +use crate::executable::document::VariableDefinitionInputType; +use crate::value::input_type::{ + InputTypeView, InputTypeViewReference, SchemaInputTypeView, VariableDefinitionInputTypeView, +}; use crate::Path; use bluejay_core::definition::{ BaseInputTypeReference, EnumTypeDefinition, EnumValueDefinition, InputFieldsDefinition, - InputObjectTypeDefinition, InputType, InputTypeReference, InputValueDefinition, - ScalarTypeDefinition, SchemaDefinition, + InputObjectTypeDefinition, InputType, InputValueDefinition, ScalarTypeDefinition, + SchemaDefinition, }; use bluejay_core::{ AsIter, BuiltinScalarDefinition, Directive, ObjectValue, Value, ValueReference, @@ -14,33 +18,16 @@ mod error; pub use error::Error; pub trait CoerceInput: SchemaDefinition { - fn coerce_value< - 'a, - const CONST: bool, - I: InputType< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - V: Value, - >( + fn coerce_value<'a, const CONST: bool, V: Value>( &'a self, - input_type: &'a I, + input_type: &'a Self::InputType, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>>; - fn coerce_const_value< - 'a, - I: InputType< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - V: Value, - >( + fn coerce_const_value<'a, V: Value>( &'a self, - input_type: &'a I, + input_type: &'a Self::InputType, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>> { @@ -49,38 +36,51 @@ pub trait CoerceInput: SchemaDefinition { } impl CoerceInput for S { - fn coerce_value< - 'a, - const CONST: bool, - I: InputType< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - V: Value, - >( + fn coerce_value<'a, const CONST: bool, V: Value>( &'a self, - input_type: &'a I, + input_type: &'a Self::InputType, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>> { - coerce_value_for_input_type(self, input_type, value, path, true) + coerce_value_for_input_type( + self, + SchemaInputTypeView::new(input_type), + value, + path, + true, + ) } } +pub(crate) fn coerce_variable_definition_value< + 'a, + const CONST: bool, + S: SchemaDefinition, + V: Value, +>( + schema_definition: &'a S, + input_type: &'a VariableDefinitionInputType<'a, S>, + value: &'a V, + path: Path<'a>, +) -> Result<(), Vec>> { + coerce_value_for_input_type( + schema_definition, + VariableDefinitionInputTypeView::new(input_type), + value, + path, + true, + ) +} + fn coerce_value_for_input_type< 'a, const CONST: bool, S: SchemaDefinition, - T: InputType< - CustomScalarTypeDefinition = S::CustomScalarTypeDefinition, - InputObjectTypeDefinition = S::InputObjectTypeDefinition, - EnumTypeDefinition = S::EnumTypeDefinition, - >, + I: InputTypeView<'a, SchemaDefinition = S>, V: Value, >( schema_definition: &'a S, - input_type: &'a T, + input_type: I, value: &'a V, path: Path<'a>, allow_implicit_list: bool, @@ -95,10 +95,10 @@ fn coerce_value_for_input_type< }]), ValueReference::Null | ValueReference::Variable(_) => Ok(()), core_value => match core_type { - InputTypeReference::Base(_, _) => { + InputTypeViewReference::Base(_, _) => { coerce_value_for_base_input_type(schema_definition, input_type, value, path) } - InputTypeReference::List(inner, _) => { + InputTypeViewReference::List(inner, _) => { if let ValueReference::List(values) = core_value { let errors: Vec> = values .iter() @@ -139,15 +139,11 @@ fn coerce_value_for_base_input_type< 'a, const CONST: bool, S: SchemaDefinition, - T: InputType< - CustomScalarTypeDefinition = S::CustomScalarTypeDefinition, - InputObjectTypeDefinition = S::InputObjectTypeDefinition, - EnumTypeDefinition = S::EnumTypeDefinition, - >, + I: InputTypeView<'a, SchemaDefinition = S>, V: Value, >( schema_definition: &'a S, - input_type: &'a T, + input_type: I, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>> { @@ -164,8 +160,14 @@ fn coerce_value_for_base_input_type< } } -fn coerce_builtin_scalar_value<'a, const CONST: bool, V: Value, T: InputType>( - input_type: &'a T, +fn coerce_builtin_scalar_value< + 'a, + const CONST: bool, + S: SchemaDefinition, + I: InputTypeView<'a, SchemaDefinition = S>, + V: Value, +>( + input_type: I, bstd: BuiltinScalarDefinition, value: &'a V, path: Path<'a>, @@ -203,9 +205,15 @@ fn coerce_custom_scalar_value<'a, const CONST: bool, V: Value>( }) } -fn coerce_enum_value<'a, const CONST: bool, V: Value, T: InputType>( - input_type: &'a T, - enum_type_definition: &'a T::EnumTypeDefinition, +fn coerce_enum_value< + 'a, + const CONST: bool, + S: SchemaDefinition, + I: InputTypeView<'a, SchemaDefinition = S>, + V: Value, +>( + input_type: I, + enum_type_definition: &'a S::EnumTypeDefinition, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>> { @@ -250,16 +258,12 @@ fn coerce_input_object_value< 'a, const CONST: bool, S: SchemaDefinition, - T: InputType< - CustomScalarTypeDefinition = S::CustomScalarTypeDefinition, - InputObjectTypeDefinition = S::InputObjectTypeDefinition, - EnumTypeDefinition = S::EnumTypeDefinition, - >, + I: InputTypeView<'a, SchemaDefinition = S>, V: Value, >( schema_definition: &'a S, - input_type: &'a T, - input_object_type_definition: &'a T::InputObjectTypeDefinition, + input_type: I, + input_object_type_definition: &'a S::InputObjectTypeDefinition, value: &'a V, path: Path<'a>, ) -> Result<(), Vec>> { diff --git a/bluejay-validator/src/value/input_type.rs b/bluejay-validator/src/value/input_type.rs new file mode 100644 index 0000000..a466939 --- /dev/null +++ b/bluejay-validator/src/value/input_type.rs @@ -0,0 +1,140 @@ +use crate::executable::document::VariableDefinitionInputType; +use bluejay_core::definition::{ + BaseInputTypeReference, InputType, InputTypeReference, SchemaDefinition, +}; +use std::fmt::{Display, Formatter}; + +pub(crate) enum InputTypeViewReference<'a, S: SchemaDefinition, I> { + Base(BaseInputTypeReference<'a, S>, bool), + List(I, bool), +} + +impl InputTypeViewReference<'_, S, I> { + pub(crate) fn is_required(&self) -> bool { + match self { + Self::Base(_, required) | Self::List(_, required) => *required, + } + } +} + +pub(crate) trait InputTypeView<'a>: Copy { + type SchemaDefinition: SchemaDefinition; + + fn as_ref( + self, + schema_definition: &'a Self::SchemaDefinition, + ) -> InputTypeViewReference<'a, Self::SchemaDefinition, Self>; + + fn display_name(self) -> String; + + fn base( + self, + schema_definition: &'a Self::SchemaDefinition, + ) -> BaseInputTypeReference<'a, Self::SchemaDefinition> { + match self.as_ref(schema_definition) { + InputTypeViewReference::Base(base, _) => base, + InputTypeViewReference::List(inner, _) => inner.base(schema_definition), + } + } +} + +pub(crate) struct SchemaInputTypeView<'a, S: SchemaDefinition> { + input_type: &'a S::InputType, +} + +impl<'a, S: SchemaDefinition> SchemaInputTypeView<'a, S> { + pub(crate) fn new(input_type: &'a S::InputType) -> Self { + Self { input_type } + } +} + +impl Clone for SchemaInputTypeView<'_, S> { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for SchemaInputTypeView<'_, S> {} + +impl<'a, S: SchemaDefinition> InputTypeView<'a> for SchemaInputTypeView<'a, S> { + type SchemaDefinition = S; + + fn as_ref(self, schema_definition: &'a S) -> InputTypeViewReference<'a, S, Self> { + match self.input_type.as_ref(schema_definition) { + InputTypeReference::Base(base, required) => { + InputTypeViewReference::Base(base, required) + } + InputTypeReference::List(inner, required) => { + InputTypeViewReference::List(Self::new(inner), required) + } + } + } + + fn display_name(self) -> String { + self.input_type.display_name() + } +} + +pub(crate) struct VariableDefinitionInputTypeView<'a, S: SchemaDefinition> { + input_type: &'a VariableDefinitionInputType<'a, S>, +} + +impl<'a, S: SchemaDefinition> VariableDefinitionInputTypeView<'a, S> { + pub(crate) fn new(input_type: &'a VariableDefinitionInputType<'a, S>) -> Self { + Self { input_type } + } +} + +impl Clone for VariableDefinitionInputTypeView<'_, S> { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for VariableDefinitionInputTypeView<'_, S> {} + +impl<'a, S: SchemaDefinition> InputTypeView<'a> for VariableDefinitionInputTypeView<'a, S> { + type SchemaDefinition = S; + + fn as_ref(self, _: &'a S) -> InputTypeViewReference<'a, S, Self> { + match self.input_type { + VariableDefinitionInputType::Base(base, required) => { + InputTypeViewReference::Base(*base, *required) + } + VariableDefinitionInputType::List(inner, required) => { + InputTypeViewReference::List(Self::new(inner.as_ref()), *required) + } + } + } + + fn display_name(self) -> String { + VariableDefinitionInputTypeDisplay(self.input_type).to_string() + } +} + +struct VariableDefinitionInputTypeDisplay<'a, 'schema, S: SchemaDefinition>( + &'a VariableDefinitionInputType<'schema, S>, +); + +impl Display for VariableDefinitionInputTypeDisplay<'_, '_, S> { + fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result { + match self.0 { + VariableDefinitionInputType::Base(base, required) => { + write!( + formatter, + "{}{}", + base.name(), + if *required { "!" } else { "" } + ) + } + VariableDefinitionInputType::List(inner, required) => { + write!( + formatter, + "[{}]{}", + Self(inner.as_ref()), + if *required { "!" } else { "" } + ) + } + } + } +} diff --git a/bluejay-visibility/src/arguments_definition.rs b/bluejay-visibility/src/arguments_definition.rs index a0a4bec..3b21ed2 100644 --- a/bluejay-visibility/src/arguments_definition.rs +++ b/bluejay-visibility/src/arguments_definition.rs @@ -43,5 +43,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::ArgumentsDefinition for ArgumentsDefinition<'a, S, W> { - type ArgumentDefinition = InputValueDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/cache.rs b/bluejay-visibility/src/cache.rs index 015c760..901d28e 100644 --- a/bluejay-visibility/src/cache.rs +++ b/bluejay-visibility/src/cache.rs @@ -29,7 +29,7 @@ impl<'a, S: SchemaDefinition, W: Warden> Cache<'a, S, W> { pub(crate) fn get_or_create_type_definition( &'a self, - type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + type_definition: TypeDefinitionReference<'a, S>, ) -> Option<&'a TypeDefinition<'a, S, W>> { match self.type_definitions.get(type_definition.name()) { Some(existing_type_definition) => self @@ -72,8 +72,8 @@ impl<'a, S: SchemaDefinition, W: Warden> Cache<'a, S, W> { fn type_definitions_equal( &self, - left: TypeDefinitionReference<'a, S::TypeDefinition>, - right: TypeDefinitionReference<'a, S::TypeDefinition>, + left: TypeDefinitionReference<'a, S>, + right: TypeDefinitionReference<'a, S>, ) -> bool { match (left, right) { ( diff --git a/bluejay-visibility/src/directive.rs b/bluejay-visibility/src/directive.rs index d07a71e..2b2dfa1 100644 --- a/bluejay-visibility/src/directive.rs +++ b/bluejay-visibility/src/directive.rs @@ -24,8 +24,8 @@ impl<'a, S: SchemaDefinition, W: Warden> Directive<'a, S, } } -impl> CoreDirective - for Directive<'_, S, W> +impl<'a, S: SchemaDefinition + 'a, W: Warden> CoreDirective + for Directive<'a, S, W> { type Arguments = >::Arguments; @@ -41,12 +41,12 @@ impl> CoreDirective impl<'a, S: SchemaDefinition, W: Warden> CoreDefinitionDirective for Directive<'a, S, W> { - type DirectiveDefinition = DirectiveDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn definition<'b, S2: SchemaDefinition>( + fn definition<'b>( &'b self, - _: &'b S2, - ) -> &'b Self::DirectiveDefinition { + _: &'b Self::SchemaDefinition, + ) -> &'b DirectiveDefinition<'a, S, W> { self.definition } } diff --git a/bluejay-visibility/src/directive_definition.rs b/bluejay-visibility/src/directive_definition.rs index 58779d4..8850f62 100644 --- a/bluejay-visibility/src/directive_definition.rs +++ b/bluejay-visibility/src/directive_definition.rs @@ -32,7 +32,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> DirectiveDef impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::DirectiveDefinition for DirectiveDefinition<'a, S, W> { - type ArgumentsDefinition = ArgumentsDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; type DirectiveLocations = ::DirectiveLocations; @@ -48,7 +48,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: self.inner.is_builtin() } - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition> { + fn arguments_definition(&self) -> Option<&ArgumentsDefinition<'a, S, W>> { self.arguments_definition .get_or_init(|| { self.inner diff --git a/bluejay-visibility/src/directives.rs b/bluejay-visibility/src/directives.rs index 3c4b22d..2eaab2d 100644 --- a/bluejay-visibility/src/directives.rs +++ b/bluejay-visibility/src/directives.rs @@ -60,5 +60,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> CoreDirectiv impl<'a, S: SchemaDefinition + 'a, W: Warden> CoreDefinitionDirectives for Directives<'a, S, W> { - type Directive = Directive<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/enum_type_definition.rs b/bluejay-visibility/src/enum_type_definition.rs index 45cf541..d7a7b76 100644 --- a/bluejay-visibility/src/enum_type_definition.rs +++ b/bluejay-visibility/src/enum_type_definition.rs @@ -27,7 +27,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> EnumTypeDefi impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::EnumTypeDefinition for EnumTypeDefinition<'a, S, W> { - type EnumValueDefinitions = EnumValueDefinitions<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -37,7 +37,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: self.inner.name() } - fn enum_value_definitions(&self) -> &Self::EnumValueDefinitions { + fn enum_value_definitions(&self) -> &EnumValueDefinitions<'a, S, W> { self.enum_value_definitions.get_or_init(|| { EnumValueDefinitions::new(self.inner.enum_value_definitions(), self.cache) }) diff --git a/bluejay-visibility/src/enum_value_definition.rs b/bluejay-visibility/src/enum_value_definition.rs index 0ad444d..d4ca3e4 100644 --- a/bluejay-visibility/src/enum_value_definition.rs +++ b/bluejay-visibility/src/enum_value_definition.rs @@ -31,6 +31,8 @@ impl<'a, S: SchemaDefinition, W: Warden> EnumValueDefiniti impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::EnumValueDefinition for EnumValueDefinition<'a, S, W> { + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; + fn description(&self) -> Option<&str> { self.inner.description() } diff --git a/bluejay-visibility/src/enum_value_definitions.rs b/bluejay-visibility/src/enum_value_definitions.rs index 307e7e8..d7bb712 100644 --- a/bluejay-visibility/src/enum_value_definitions.rs +++ b/bluejay-visibility/src/enum_value_definitions.rs @@ -43,5 +43,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::EnumValueDefinitions for EnumValueDefinitions<'a, S, W> { - type EnumValueDefinition = EnumValueDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/field_definition.rs b/bluejay-visibility/src/field_definition.rs index c8300f3..89d5350 100644 --- a/bluejay-visibility/src/field_definition.rs +++ b/bluejay-visibility/src/field_definition.rs @@ -38,8 +38,7 @@ impl<'a, S: SchemaDefinition, W: Warden> FieldDefinition<' impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::FieldDefinition for FieldDefinition<'a, S, W> { - type OutputType = OutputType<'a, S, W>; - type ArgumentsDefinition = ArgumentsDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -53,11 +52,11 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: self.inner.is_builtin() } - fn r#type(&self) -> &Self::OutputType { + fn r#type(&self) -> &OutputType<'a, S, W> { &self.r#type } - fn arguments_definition(&self) -> Option<&Self::ArgumentsDefinition> { + fn arguments_definition(&self) -> Option<&ArgumentsDefinition<'a, S, W>> { self.arguments_definition .get_or_init(|| { self.inner diff --git a/bluejay-visibility/src/fields_definition.rs b/bluejay-visibility/src/fields_definition.rs index 2551a3d..49fec0b 100644 --- a/bluejay-visibility/src/fields_definition.rs +++ b/bluejay-visibility/src/fields_definition.rs @@ -69,9 +69,9 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::FieldsDefinition for FieldsDefinition<'a, S, W> { - type FieldDefinition = FieldDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn get(&self, name: &str) -> Option<&Self::FieldDefinition> { + fn get(&self, name: &str) -> Option<&FieldDefinition<'a, S, W>> { self.indexed_fields_definition .get(name) .or_else(|| { diff --git a/bluejay-visibility/src/input_fields_definition.rs b/bluejay-visibility/src/input_fields_definition.rs index 0118e74..ea5daee 100644 --- a/bluejay-visibility/src/input_fields_definition.rs +++ b/bluejay-visibility/src/input_fields_definition.rs @@ -43,5 +43,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InputFieldsDefinition for InputFieldsDefinition<'a, S, W> { - type InputValueDefinition = InputValueDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/input_object_type_definition.rs b/bluejay-visibility/src/input_object_type_definition.rs index 9c3af0f..f36aa07 100644 --- a/bluejay-visibility/src/input_object_type_definition.rs +++ b/bluejay-visibility/src/input_object_type_definition.rs @@ -29,7 +29,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InputObjectTypeDefinition for InputObjectTypeDefinition<'a, S, W> { - type InputFieldsDefinition = InputFieldsDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -39,7 +39,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> self.inner.name() } - fn input_field_definitions(&self) -> &Self::InputFieldsDefinition { + fn input_field_definitions(&self) -> &InputFieldsDefinition<'a, S, W> { self.input_fields_definition.get_or_init(|| { InputFieldsDefinition::new(self.inner.input_field_definitions(), self.cache) }) diff --git a/bluejay-visibility/src/input_type.rs b/bluejay-visibility/src/input_type.rs index f23bb65..532475c 100644 --- a/bluejay-visibility/src/input_type.rs +++ b/bluejay-visibility/src/input_type.rs @@ -1,14 +1,14 @@ -use crate::{ - Cache, EnumTypeDefinition, InputObjectTypeDefinition, ScalarTypeDefinition, TypeDefinition, - Warden, -}; +use crate::{Cache, TypeDefinition, Warden}; use bluejay_core::definition::{ self, prelude::*, BaseInputTypeReference, InputTypeReference, SchemaDefinition, TypeDefinitionReference, }; pub enum InputType<'a, S: SchemaDefinition + 'a, W: Warden + 'a> { - Base(BaseInputTypeReference<'a, Self>, bool), + Base( + BaseInputTypeReference<'a, crate::SchemaDefinition<'a, S, W>>, + bool, + ), List(Box, bool), } @@ -25,9 +25,9 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden + 'a> InputTy } fn new_base( - inner: BaseInputTypeReference<'a, S::InputType>, + inner: BaseInputTypeReference<'a, S>, cache: &'a Cache<'a, S, W>, - ) -> Option> { + ) -> Option>> { let tdr = match inner { BaseInputTypeReference::BuiltinScalar(bstd) => { TypeDefinitionReference::BuiltinScalar(bstd) @@ -54,7 +54,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden + 'a> InputTy }) } - pub(crate) fn base(&self) -> BaseInputTypeReference<'a, Self> { + pub(crate) fn base(&self) -> BaseInputTypeReference<'a, crate::SchemaDefinition<'a, S, W>> { match self { Self::Base(base, _) => *base, Self::List(inner, _) => inner.base(), @@ -65,28 +65,19 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden + 'a> InputTy impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InputType for InputType<'a, S, W> { - type CustomScalarTypeDefinition = ScalarTypeDefinition<'a, S, W>; - type EnumTypeDefinition = EnumTypeDefinition<'a, S, W>; - type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn as_ref< - 'b, - S2: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - InputObjectTypeDefinition = Self::InputObjectTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - >, - >( + fn as_ref<'b>( &'b self, - _: &'b S2, - ) -> InputTypeReference<'b, Self> { + _: &'b Self::SchemaDefinition, + ) -> InputTypeReference<'b, Self::SchemaDefinition> { match self { Self::Base(b, required) => InputTypeReference::Base(*b, *required), - Self::List(inner, required) => InputTypeReference::List(inner, *required), + Self::List(inner, required) => InputTypeReference::List(inner.as_ref(), *required), } } - fn as_shallow_ref(&self) -> definition::ShallowInputTypeReference<'_, Self> { + fn as_shallow_ref(&self) -> definition::ShallowInputTypeReference<'_, Self::SchemaDefinition> { match self { Self::Base(base, required) => { definition::ShallowInputTypeReference::Base(base.name(), *required) diff --git a/bluejay-visibility/src/input_value_definition.rs b/bluejay-visibility/src/input_value_definition.rs index 059021a..8df0fad 100644 --- a/bluejay-visibility/src/input_value_definition.rs +++ b/bluejay-visibility/src/input_value_definition.rs @@ -41,8 +41,8 @@ impl<'a, S: SchemaDefinition, W: Warden> InputValueDefinit impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InputValueDefinition for InputValueDefinition<'a, S, W> { + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; type Value = ::Value; - type InputType = InputType<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -58,7 +58,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: .input_value_definition_default_value(self) } - fn r#type(&self) -> &Self::InputType { + fn r#type(&self) -> &InputType<'a, S, W> { &self.r#type } } diff --git a/bluejay-visibility/src/interface_implementation.rs b/bluejay-visibility/src/interface_implementation.rs index bdd5110..7486c8c 100644 --- a/bluejay-visibility/src/interface_implementation.rs +++ b/bluejay-visibility/src/interface_implementation.rs @@ -42,15 +42,12 @@ impl<'a, S: SchemaDefinition, W: Warden> InterfaceImplemen impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InterfaceImplementation for InterfaceImplementation<'a, S, W> { - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn interface< - 'b, - S2: SchemaDefinition, - >( + fn interface<'b>( &'b self, - _: &'b S2, - ) -> &'b Self::InterfaceTypeDefinition { + _: &'b Self::SchemaDefinition, + ) -> &'b InterfaceTypeDefinition<'a, S, W> { self.interface } diff --git a/bluejay-visibility/src/interface_implementations.rs b/bluejay-visibility/src/interface_implementations.rs index 987e603..5174e3a 100644 --- a/bluejay-visibility/src/interface_implementations.rs +++ b/bluejay-visibility/src/interface_implementations.rs @@ -43,5 +43,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InterfaceImplementations for InterfaceImplementations<'a, S, W> { - type InterfaceImplementation = InterfaceImplementation<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/interface_type_definition.rs b/bluejay-visibility/src/interface_type_definition.rs index e2b7d17..5ff66e3 100644 --- a/bluejay-visibility/src/interface_type_definition.rs +++ b/bluejay-visibility/src/interface_type_definition.rs @@ -31,8 +31,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::InterfaceTypeDefinition for InterfaceTypeDefinition<'a, S, W> { - type FieldsDefinition = FieldsDefinition<'a, S, W>; - type InterfaceImplementations = InterfaceImplementations<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -42,12 +41,12 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> self.inner.name() } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, S, W> { self.fields_definition .get_or_init(|| FieldsDefinition::new(self.inner.fields_definition(), self.cache)) } - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations> { + fn interface_implementations(&self) -> Option<&InterfaceImplementations<'a, S, W>> { self.interface_implementations .get_or_init(|| { self.inner diff --git a/bluejay-visibility/src/object_type_definition.rs b/bluejay-visibility/src/object_type_definition.rs index 2b53a2b..132e3b1 100644 --- a/bluejay-visibility/src/object_type_definition.rs +++ b/bluejay-visibility/src/object_type_definition.rs @@ -29,8 +29,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> ObjectTypeDe impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::ObjectTypeDefinition for ObjectTypeDefinition<'a, S, W> { - type FieldsDefinition = FieldsDefinition<'a, S, W>; - type InterfaceImplementations = InterfaceImplementations<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -40,12 +39,12 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: self.inner.name() } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, S, W> { self.fields_definition .get_or_init(|| FieldsDefinition::new(self.inner.fields_definition(), self.cache)) } - fn interface_implementations(&self) -> Option<&Self::InterfaceImplementations> { + fn interface_implementations(&self) -> Option<&InterfaceImplementations<'a, S, W>> { self.interface_implementations .get_or_init(|| { self.inner diff --git a/bluejay-visibility/src/output_type.rs b/bluejay-visibility/src/output_type.rs index 0f82281..de4e197 100644 --- a/bluejay-visibility/src/output_type.rs +++ b/bluejay-visibility/src/output_type.rs @@ -1,14 +1,14 @@ -use crate::{ - Cache, EnumTypeDefinition, InterfaceTypeDefinition, ObjectTypeDefinition, ScalarTypeDefinition, - TypeDefinition, UnionTypeDefinition, Warden, -}; +use crate::{Cache, TypeDefinition, Warden}; use bluejay_core::definition::{ self, prelude::*, BaseOutputTypeReference, OutputTypeReference, SchemaDefinition, ShallowOutputTypeReference, TypeDefinitionReference, }; pub enum OutputType<'a, S: SchemaDefinition + 'a, W: Warden + 'a> { - Base(BaseOutputTypeReference<'a, Self>, bool), + Base( + BaseOutputTypeReference<'a, crate::SchemaDefinition<'a, S, W>>, + bool, + ), List(Box, bool), } @@ -25,9 +25,9 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> OutputType<' } fn new_base( - inner: BaseOutputTypeReference<'a, S::OutputType>, + inner: BaseOutputTypeReference<'a, S>, cache: &'a Cache<'a, S, W>, - ) -> Option> { + ) -> Option>> { let tdr = match inner { BaseOutputTypeReference::BuiltinScalar(bstd) => { TypeDefinitionReference::BuiltinScalar(bstd) @@ -58,7 +58,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> OutputType<' }) } - pub(crate) fn base(&self) -> BaseOutputTypeReference<'_, Self> { + pub(crate) fn base(&self) -> BaseOutputTypeReference<'_, crate::SchemaDefinition<'a, S, W>> { match self { Self::Base(b, _) => *b, Self::List(inner, _) => inner.base(), @@ -69,32 +69,19 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> OutputType<' impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::OutputType for OutputType<'a, S, W> { - type ObjectTypeDefinition = ObjectTypeDefinition<'a, S, W>; - type CustomScalarTypeDefinition = ScalarTypeDefinition<'a, S, W>; - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, S, W>; - type EnumTypeDefinition = EnumTypeDefinition<'a, S, W>; - type UnionTypeDefinition = UnionTypeDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn as_ref< - 'b, - S2: SchemaDefinition< - CustomScalarTypeDefinition = Self::CustomScalarTypeDefinition, - EnumTypeDefinition = Self::EnumTypeDefinition, - ObjectTypeDefinition = Self::ObjectTypeDefinition, - InterfaceTypeDefinition = Self::InterfaceTypeDefinition, - UnionTypeDefinition = Self::UnionTypeDefinition, - >, - >( + fn as_ref<'b>( &'b self, - _: &'b S2, - ) -> OutputTypeReference<'b, Self> { + _: &'b Self::SchemaDefinition, + ) -> OutputTypeReference<'b, Self::SchemaDefinition> { match self { Self::Base(b, required) => OutputTypeReference::Base(*b, *required), Self::List(inner, required) => OutputTypeReference::List(inner.as_ref(), *required), } } - fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self> { + fn as_shallow_ref(&self) -> ShallowOutputTypeReference<'_, Self::SchemaDefinition> { match self { Self::Base(b, required) => ShallowOutputTypeReference::Base(b.name(), *required), Self::List(inner, required) => { diff --git a/bluejay-visibility/src/scalar_type_definition.rs b/bluejay-visibility/src/scalar_type_definition.rs index 2b5df7b..c341f2e 100644 --- a/bluejay-visibility/src/scalar_type_definition.rs +++ b/bluejay-visibility/src/scalar_type_definition.rs @@ -24,9 +24,11 @@ impl<'a, S: SchemaDefinition, W: Warden> ScalarTypeDefinit } } -impl> definition::ScalarTypeDefinition - for ScalarTypeDefinition<'_, S, W> +impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::ScalarTypeDefinition + for ScalarTypeDefinition<'a, S, W> { + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; + fn description(&self) -> Option<&str> { self.inner.description() } diff --git a/bluejay-visibility/src/schema_definition.rs b/bluejay-visibility/src/schema_definition.rs index b5c1be0..c7e528f 100644 --- a/bluejay-visibility/src/schema_definition.rs +++ b/bluejay-visibility/src/schema_definition.rs @@ -161,9 +161,7 @@ impl<'a, S: definition::SchemaDefinition + 'a, W: Warden> type TypeDefinition = TypeDefinition<'a, S, W>; type DirectiveDefinition = DirectiveDefinition<'a, S, W>; type TypeDefinitions<'b> - = std::iter::Copied< - btree_map::Values<'b, &'a str, TypeDefinitionReference<'b, Self::TypeDefinition>>, - > + = std::iter::Copied>> where 'a: 'b; type DirectiveDefinitions<'b> @@ -201,7 +199,7 @@ impl<'a, S: definition::SchemaDefinition + 'a, W: Warden> fn get_type_definition( &self, name: &str, - ) -> Option> { + ) -> Option> { self.cache .get_type_definition(name) .or_else(|| { @@ -247,7 +245,7 @@ struct TypeDefinitionsAndDirectiveDefinitions< S: definition::SchemaDefinition, W: Warden, > { - type_definitions: BTreeMap<&'a str, TypeDefinitionReference<'a, TypeDefinition<'a, S, W>>>, + type_definitions: BTreeMap<&'a str, TypeDefinitionReference<'a, SchemaDefinition<'a, S, W>>>, directive_definitions: BTreeMap<&'a str, &'a DirectiveDefinition<'a, S, W>>, } @@ -269,7 +267,7 @@ impl<'a, S: definition::SchemaDefinition, W: Warden> struct VisibilityVisitor<'a, 'b, S: definition::SchemaDefinition, W: Warden> { schema_definition: &'b SchemaDefinition<'a, S, W>, - type_definitions: BTreeMap<&'a str, TypeDefinitionReference<'a, TypeDefinition<'a, S, W>>>, + type_definitions: BTreeMap<&'a str, TypeDefinitionReference<'a, SchemaDefinition<'a, S, W>>>, directive_definitions: BTreeMap<&'a str, &'a DirectiveDefinition<'a, S, W>>, } @@ -317,7 +315,7 @@ impl<'a, 'b, S: definition::SchemaDefinition, W: Warden> fn visit_type_definition( &mut self, - type_definition: TypeDefinitionReference<'a, TypeDefinition<'a, S, W>>, + type_definition: TypeDefinitionReference<'a, SchemaDefinition<'a, S, W>>, ) { if let Entry::Vacant(entry) = self.type_definitions.entry(type_definition.name()) { entry.insert(type_definition); diff --git a/bluejay-visibility/src/type_definition.rs b/bluejay-visibility/src/type_definition.rs index 97bdd0f..19444d2 100644 --- a/bluejay-visibility/src/type_definition.rs +++ b/bluejay-visibility/src/type_definition.rs @@ -19,7 +19,7 @@ pub enum TypeDefinition<'a, S: SchemaDefinition, W: Warden impl<'a, S: SchemaDefinition + 'a, W: Warden> TypeDefinition<'a, S, W> { pub(crate) fn new( - type_definition: TypeDefinitionReference<'a, S::TypeDefinition>, + type_definition: TypeDefinitionReference<'a, S>, cache: &'a Cache<'a, S, W>, ) -> Option { let warden = cache.warden(); @@ -46,7 +46,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> TypeDefiniti } } - pub(crate) fn inner(&self) -> TypeDefinitionReference<'_, S::TypeDefinition> { + pub(crate) fn inner(&self) -> TypeDefinitionReference<'_, S> { match self { Self::BuiltinScalar(bstd) => TypeDefinitionReference::BuiltinScalar(*bstd), Self::CustomScalar(cstd) => TypeDefinitionReference::CustomScalar(cstd.inner()), @@ -62,14 +62,9 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> TypeDefiniti impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::TypeDefinition for TypeDefinition<'a, S, W> { - type ObjectTypeDefinition = ObjectTypeDefinition<'a, S, W>; - type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, S, W>; - type CustomScalarTypeDefinition = ScalarTypeDefinition<'a, S, W>; - type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, S, W>; - type EnumTypeDefinition = EnumTypeDefinition<'a, S, W>; - type UnionTypeDefinition = UnionTypeDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn as_ref(&self) -> TypeDefinitionReference<'_, Self> { + fn as_ref(&self) -> TypeDefinitionReference<'_, Self::SchemaDefinition> { match self { Self::Object(otd) => TypeDefinitionReference::Object(otd), Self::Interface(itd) => TypeDefinitionReference::Interface(itd), diff --git a/bluejay-visibility/src/union_member_type.rs b/bluejay-visibility/src/union_member_type.rs index af7cc79..472d60e 100644 --- a/bluejay-visibility/src/union_member_type.rs +++ b/bluejay-visibility/src/union_member_type.rs @@ -39,12 +39,12 @@ impl<'a, S: SchemaDefinition, W: Warden> UnionMemberType<' impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::UnionMemberType for UnionMemberType<'a, S, W> { - type ObjectTypeDefinition = ObjectTypeDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; - fn member_type<'b, S2: SchemaDefinition>( + fn member_type<'b>( &'b self, - _: &'b S2, - ) -> &'b Self::ObjectTypeDefinition { + _: &'b Self::SchemaDefinition, + ) -> &'b ObjectTypeDefinition<'a, S, W> { self.member_type } diff --git a/bluejay-visibility/src/union_member_types.rs b/bluejay-visibility/src/union_member_types.rs index 5280971..c372d75 100644 --- a/bluejay-visibility/src/union_member_types.rs +++ b/bluejay-visibility/src/union_member_types.rs @@ -43,5 +43,5 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> AsIter impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::UnionMemberTypes for UnionMemberTypes<'a, S, W> { - type UnionMemberType = UnionMemberType<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; } diff --git a/bluejay-visibility/src/union_type_definition.rs b/bluejay-visibility/src/union_type_definition.rs index c7587b4..758f38b 100644 --- a/bluejay-visibility/src/union_type_definition.rs +++ b/bluejay-visibility/src/union_type_definition.rs @@ -29,8 +29,7 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> UnionTypeDef impl<'a, S: SchemaDefinition + 'a, W: Warden> definition::UnionTypeDefinition for UnionTypeDefinition<'a, S, W> { - type UnionMemberTypes = UnionMemberTypes<'a, S, W>; - type FieldsDefinition = FieldsDefinition<'a, S, W>; + type SchemaDefinition = crate::SchemaDefinition<'a, S, W>; fn description(&self) -> Option<&str> { self.inner.description() @@ -40,12 +39,12 @@ impl<'a, S: SchemaDefinition + 'a, W: Warden> definition:: self.inner.name() } - fn union_member_types(&self) -> &Self::UnionMemberTypes { + fn union_member_types(&self) -> &UnionMemberTypes<'a, S, W> { self.union_member_types .get_or_init(|| UnionMemberTypes::new(self.inner.union_member_types(), self.cache)) } - fn fields_definition(&self) -> &Self::FieldsDefinition { + fn fields_definition(&self) -> &FieldsDefinition<'a, S, W> { self.fields_definition .get_or_init(|| FieldsDefinition::new(self.inner.fields_definition(), self.cache)) } diff --git a/bluejay-visibility/src/warden.rs b/bluejay-visibility/src/warden.rs index 8288dd7..b07d361 100644 --- a/bluejay-visibility/src/warden.rs +++ b/bluejay-visibility/src/warden.rs @@ -9,12 +9,8 @@ use std::marker::PhantomData; pub trait Warden: Sized { type SchemaDefinition: SchemaDefinition; - type TypeDefinitionsForName<'a>: Iterator< - Item = TypeDefinitionReference< - 'a, - ::TypeDefinition, - >, - > + 'a + type TypeDefinitionsForName<'a>: Iterator> + + 'a where Self: 'a; @@ -171,7 +167,7 @@ impl Default for NullWarden { impl Warden for NullWarden { type SchemaDefinition = S; type TypeDefinitionsForName<'a> - = std::option::IntoIter> + = std::option::IntoIter> where Self: 'a; diff --git a/bluejay-visibility/tests/integration_test.rs b/bluejay-visibility/tests/integration_test.rs index 59f4f34..df27c2e 100644 --- a/bluejay-visibility/tests/integration_test.rs +++ b/bluejay-visibility/tests/integration_test.rs @@ -1,5 +1,5 @@ use bluejay_core::{ - definition::{prelude::*, SchemaDefinition as CoreSchemaDefinition, TypeDefinitionReference}, + definition::{prelude::*, TypeDefinitionReference}, AsIter, Directive as _, }; use bluejay_parser::{ @@ -32,12 +32,7 @@ impl<'a> DirectiveWarden<'a> { impl<'a> Warden for DirectiveWarden<'a> { type SchemaDefinition = ParserSchemaDefinition<'a>; type TypeDefinitionsForName<'b> - = std::option::IntoIter< - TypeDefinitionReference< - 'b, - ::TypeDefinition, - >, - > + = std::option::IntoIter> where Self: 'b;