From c055736101fb3959a57bb6de37bb3dafae9ba541 Mon Sep 17 00:00:00 2001 From: Koxiaet <38139193+Koxiaet@users.noreply.github.com> Date: Sun, 6 Sep 2020 07:16:36 +0100 Subject: [PATCH] Rustfmt --- async-graphql-parser/src/lib.rs | 11 +- async-graphql-parser/src/parser.rs | 149 +++++++++--------- async-graphql-parser/src/types.rs | 30 ++-- async-graphql-parser/src/utils.rs | 12 +- src/base.rs | 2 +- src/context.rs | 36 +++-- src/extensions/logger.rs | 2 +- src/extensions/mod.rs | 2 +- src/lib.rs | 2 +- src/look_ahead.rs | 3 +- src/mutation_resolver.rs | 7 +- src/query.rs | 34 ++-- src/registry.rs | 8 +- src/scalars/json.rs | 2 +- src/scalars/string.rs | 2 +- src/schema.rs | 18 ++- src/subscription/subscription_type.rs | 31 ++-- src/types/connection/connection_type.rs | 2 +- src/types/connection/edge.rs | 2 +- src/types/empty_mutation.rs | 2 +- src/types/list.rs | 2 +- src/types/merged_object.rs | 2 +- src/types/optional.rs | 2 +- src/types/query_root.rs | 2 +- src/types/upload.rs | 2 +- .../rules/arguments_of_correct_type.rs | 6 +- src/validation/rules/known_directives.rs | 14 +- src/validation/rules/known_fragment_names.rs | 5 +- src/validation/rules/known_type_names.rs | 7 +- src/validation/rules/no_fragment_cycles.rs | 8 +- .../rules/no_undefined_variables.rs | 6 +- src/validation/rules/no_unused_fragments.rs | 25 ++- src/validation/rules/no_unused_variables.rs | 11 +- .../rules/overlapping_fields_can_be_merged.rs | 4 +- .../rules/possible_fragment_spreads.rs | 7 +- src/validation/rules/upload_file.rs | 5 +- .../rules/variables_in_allowed_position.rs | 21 ++- src/validation/test_harness.rs | 2 +- src/validation/visitor.rs | 7 +- tests/input_validators.rs | 4 +- 40 files changed, 292 insertions(+), 207 deletions(-) diff --git a/async-graphql-parser/src/lib.rs b/async-graphql-parser/src/lib.rs index 285f1405..4ac8aeb3 100644 --- a/async-graphql-parser/src/lib.rs +++ b/async-graphql-parser/src/lib.rs @@ -5,17 +5,17 @@ //! it into Rust types. #![forbid(unsafe_code)] -use std::fmt; -use pest::RuleType; use pest::error::LineColLocation; +use pest::RuleType; +use std::fmt; -pub use pos::{Pos, Positioned}; pub use parser::parse_query; +pub use pos::{Pos, Positioned}; pub mod types; -mod pos; mod parser; +mod pos; mod utils; /// Parser error. @@ -40,7 +40,8 @@ impl From> for Error { Error { pos: { match err.line_col { - LineColLocation::Pos((line, column)) | LineColLocation::Span((line, column), _) => Pos { line, column }, + LineColLocation::Pos((line, column)) + | LineColLocation::Span((line, column), _) => Pos { line, column }, } }, message: err.to_string(), diff --git a/async-graphql-parser/src/parser.rs b/async-graphql-parser/src/parser.rs index 74ed1b09..c43a34fc 100644 --- a/async-graphql-parser/src/parser.rs +++ b/async-graphql-parser/src/parser.rs @@ -1,6 +1,6 @@ use crate::pos::Positioned; use crate::types::*; -use crate::utils::{string_value, block_string_value, PositionCalculator}; +use crate::utils::{block_string_value, string_value, PositionCalculator}; use crate::Result; use pest::iterators::{Pair, Pairs}; use pest::Parser; @@ -17,21 +17,25 @@ struct GraphQLParser; /// Fails if the query is not a valid GraphQL document. pub fn parse_query>(input: T) -> Result { let mut pc = PositionCalculator::new(input.as_ref()); - Ok(parse_document(exactly_one(GraphQLParser::parse(Rule::document, input.as_ref())?), &mut pc)) + Ok(parse_document( + exactly_one(GraphQLParser::parse(Rule::document, input.as_ref())?), + &mut pc, + )) } fn parse_document(pair: Pair, pc: &mut PositionCalculator) -> Document { debug_assert_eq!(pair.as_rule(), Rule::document); Document { - definitions: pair.into_inner().filter(|pair| pair.as_rule() != Rule::EOI).map(|pair| parse_definition(pair, pc)).collect(), + definitions: pair + .into_inner() + .filter(|pair| pair.as_rule() != Rule::EOI) + .map(|pair| parse_definition(pair, pc)) + .collect(), } } -fn parse_definition( - pair: Pair, - pc: &mut PositionCalculator, -) -> Definition { +fn parse_definition(pair: Pair, pc: &mut PositionCalculator) -> Definition { debug_assert_eq!(pair.as_rule(), Rule::definition); let pair = exactly_one(pair.into_inner()); @@ -50,17 +54,20 @@ fn parse_operation_definition( let pos = pc.step(&pair); let pair = exactly_one(pair.into_inner()); - Positioned::new(match pair.as_rule() { - Rule::named_operation_definition => parse_named_operation_definition(pair, pc), - Rule::selection_set => OperationDefinition { - ty: OperationType::Query, - name: None, - variable_definitions: Vec::new(), - directives: Vec::new(), - selection_set: parse_selection_set(pair, pc), + Positioned::new( + match pair.as_rule() { + Rule::named_operation_definition => parse_named_operation_definition(pair, pc), + Rule::selection_set => OperationDefinition { + ty: OperationType::Query, + name: None, + variable_definitions: Vec::new(), + directives: Vec::new(), + selection_set: parse_selection_set(pair, pc), + }, + _ => unreachable!(), }, - _ => unreachable!(), - }, pos) + pos, + ) } fn parse_named_operation_definition( @@ -73,8 +80,10 @@ fn parse_named_operation_definition( let ty = parse_operation_type(&pairs.next().unwrap(), pc); let name = next_if_rule(&mut pairs, Rule::name).map(|pair| parse_name(&pair, pc)); - let variable_definitions = next_if_rule(&mut pairs, Rule::variable_definitions).map(|pair| parse_variable_definitions(pair, pc)); - let directives = next_if_rule(&mut pairs, Rule::directives).map(|pair| parse_directives(pair, pc)); + let variable_definitions = next_if_rule(&mut pairs, Rule::variable_definitions) + .map(|pair| parse_variable_definitions(pair, pc)); + let directives = + next_if_rule(&mut pairs, Rule::directives).map(|pair| parse_directives(pair, pc)); let selection_set = parse_selection_set(pairs.next().unwrap(), pc); debug_assert_eq!(pairs.next(), None); @@ -84,21 +93,27 @@ fn parse_named_operation_definition( name, variable_definitions: variable_definitions.unwrap_or_default(), directives: directives.unwrap_or_default(), - selection_set + selection_set, } } -fn parse_operation_type(pair: &Pair, pc: &mut PositionCalculator) -> Positioned { +fn parse_operation_type( + pair: &Pair, + pc: &mut PositionCalculator, +) -> Positioned { debug_assert_eq!(pair.as_rule(), Rule::operation_type); let pos = pc.step(&pair); - Positioned::new(match pair.as_str() { - "query" => OperationType::Query, - "mutation" => OperationType::Mutation, - "subscription" => OperationType::Subscription, - _ => unreachable!(), - }, pos) + Positioned::new( + match pair.as_str() { + "query" => OperationType::Query, + "mutation" => OperationType::Mutation, + "subscription" => OperationType::Subscription, + _ => unreachable!(), + }, + pos, + ) } fn parse_variable_definitions( @@ -107,7 +122,9 @@ fn parse_variable_definitions( ) -> Vec> { debug_assert_eq!(pair.as_rule(), Rule::variable_definitions); - pair.into_inner().map(|pair| parse_variable_definition(pair, pc)).collect() + pair.into_inner() + .map(|pair| parse_variable_definition(pair, pc)) + .collect() } fn parse_variable_definition( @@ -162,7 +179,9 @@ fn parse_value(pair: Pair, pc: &mut PositionCalculator) -> Positioned Value::Variable(parse_variable(pair, pc).node), - Rule::float | Rule::int => Value::Number(pair.as_str().parse().expect("failed to parse number")), + Rule::float | Rule::int => { + Value::Number(pair.as_str().parse().expect("failed to parse number")) + } Rule::string => Value::String({ let pair = exactly_one(pair.into_inner()); match pair.as_rule() { @@ -213,10 +232,7 @@ fn parse_name_value( (name, value) } -fn parse_selection_set( - pair: Pair, - pc: &mut PositionCalculator, -) -> Positioned { +fn parse_selection_set(pair: Pair, pc: &mut PositionCalculator) -> Positioned { debug_assert_eq!(pair.as_rule(), Rule::selection_set); let pos = pc.step(&pair); @@ -238,12 +254,15 @@ fn parse_selection(pair: Pair, pc: &mut PositionCalculator) -> Positioned< let pos = pc.step(&pair); let pair = exactly_one(pair.into_inner()); - Positioned::new(match pair.as_rule() { - Rule::field => Selection::Field(parse_field(pair, pc)), - Rule::fragment_spread => Selection::FragmentSpread(parse_fragment_spread(pair, pc)), - Rule::inline_fragment => Selection::InlineFragment(parse_inline_fragment(pair, pc)), - _ => unreachable!(), - }, pos) + Positioned::new( + match pair.as_rule() { + Rule::field => Selection::Field(parse_field(pair, pc)), + Rule::fragment_spread => Selection::FragmentSpread(parse_fragment_spread(pair, pc)), + Rule::inline_fragment => Selection::InlineFragment(parse_inline_fragment(pair, pc)), + _ => unreachable!(), + }, + pos, + ) } fn parse_field(pair: Pair, pc: &mut PositionCalculator) -> Positioned { @@ -252,19 +271,13 @@ fn parse_field(pair: Pair, pc: &mut PositionCalculator) -> Positioned, - pc: &mut PositionCalculator, -) -> Vec> { +fn parse_directives(pair: Pair, pc: &mut PositionCalculator) -> Vec> { debug_assert_eq!(pair.as_rule(), Rule::directives); - pair.into_inner().map(|pair| parse_directive(pair, pc)).collect() + pair.into_inner() + .map(|pair| parse_directive(pair, pc)) + .collect() } fn parse_directive(pair: Pair, pc: &mut PositionCalculator) -> Positioned { @@ -409,9 +414,7 @@ fn parse_directive(pair: Pair, pc: &mut PositionCalculator) -> Positioned< let mut pairs = pair.into_inner(); let name = parse_name(&pairs.next().unwrap(), pc); - let arguments = pairs - .next() - .map(|pair| parse_arguments(pair, pc)); + let arguments = pairs.next().map(|pair| parse_arguments(pair, pc)); debug_assert_eq!(pairs.peek(), None); diff --git a/async-graphql-parser/src/types.rs b/async-graphql-parser/src/types.rs index 3b9b48b8..d0565949 100644 --- a/async-graphql-parser/src/types.rs +++ b/async-graphql-parser/src/types.rs @@ -1,9 +1,9 @@ //! GraphQL types. use crate::pos::{Pos, Positioned}; -use std::fmt::{self, Formatter, Write}; use serde::{Serialize, Serializer}; -use std::collections::{HashMap, BTreeMap}; +use std::collections::{BTreeMap, HashMap}; +use std::fmt::{self, Formatter, Write}; use std::fs::File; /// A complete GraphQL file or request string. @@ -28,7 +28,15 @@ impl Document { for definition in self.definitions { match definition { - Definition::Operation(op) if operation_name.zip(op.node.name.as_ref()).map_or(false, |(required_name, op_name)| required_name != op_name.node) => (), + Definition::Operation(op) + if operation_name + .zip(op.node.name.as_ref()) + .map_or(false, |(required_name, op_name)| { + required_name != op_name.node + }) => + { + () + } Definition::Operation(op) => { operation.get_or_insert(op); } @@ -151,11 +159,16 @@ impl VariableDefinition { /// `Value::Null` if it is nullable and `None` otherwise. #[must_use] pub fn default_value(&self) -> Option<&Value> { - self.default_value.as_ref().map(|value| &value.node).or_else(|| if self.var_type.node.nullable { - Some(&Value::Null) - } else { - None - }) + self.default_value + .as_ref() + .map(|value| &value.node) + .or_else(|| { + if self.var_type.node.nullable { + Some(&Value::Null) + } else { + None + } + }) } } @@ -401,7 +414,6 @@ pub struct SelectionSet { pub items: Vec>, } - /// A part of an object to be selected; a single field, a fragment spread or an inline fragment. /// /// [Reference](https://spec.graphql.org/June2018/#Selection). diff --git a/async-graphql-parser/src/utils.rs b/async-graphql-parser/src/utils.rs index 750fe6c5..6db3443c 100644 --- a/async-graphql-parser/src/utils.rs +++ b/async-graphql-parser/src/utils.rs @@ -87,14 +87,10 @@ pub(crate) fn block_string_value(raw: &str) -> String { // Put a newline between each line .enumerate() .flat_map(|(i, line)| { - if i == 0 { - [].as_ref() - } else { - ['\n'].as_ref() - } - .iter() - .copied() - .chain(line.chars()) + if i == 0 { [].as_ref() } else { ['\n'].as_ref() } + .iter() + .copied() + .chain(line.chars()) }) .collect() } diff --git a/src/base.rs b/src/base.rs index 0ac66a8d..e1aea956 100644 --- a/src/base.rs +++ b/src/base.rs @@ -1,9 +1,9 @@ +use crate::parser::types::Field; use crate::registry::Registry; use crate::{ registry, Context, ContextSelectionSet, FieldResult, InputValueResult, Positioned, QueryError, Result, Value, }; -use crate::parser::types::Field; use std::borrow::Cow; use std::future::Future; use std::pin::Pin; diff --git a/src/context.rs b/src/context.rs index 651a45b9..b0fde8a3 100644 --- a/src/context.rs +++ b/src/context.rs @@ -1,9 +1,7 @@ -use crate::extensions::Extensions; -use crate::parser::types::{ - Directive, ExecutableDocument, Field, SelectionSet, Value, -}; -use crate::schema::SchemaEnv; use crate::base::Type; +use crate::extensions::Extensions; +use crate::parser::types::{Directive, ExecutableDocument, Field, SelectionSet, Value}; +use crate::schema::SchemaEnv; use crate::{FieldResult, InputValueType, Lookahead, Pos, Positioned, QueryError, Result}; use fnv::FnvHashMap; use serde::ser::SerializeSeq; @@ -405,15 +403,28 @@ impl<'a, T> ContextBase<'a, T> { _ => continue, }; - let Positioned { node: mut condition_input, pos } = directive.node.get_argument("if").ok_or_else(|| QueryError::RequiredDirectiveArgs { - directive: if include { "@skip" } else { "@include" }, - arg_name: "if", - arg_type: "Boolean!", - }.into_error(directive.pos))?.clone(); + let Positioned { + node: mut condition_input, + pos, + } = directive + .node + .get_argument("if") + .ok_or_else(|| { + QueryError::RequiredDirectiveArgs { + directive: if include { "@skip" } else { "@include" }, + arg_name: "if", + arg_type: "Boolean!", + } + .into_error(directive.pos) + })? + .clone(); self.resolve_input_value(&mut condition_input, pos)?; - if include != ::parse(Some(condition_input)).map_err(|e| e.into_error(pos, bool::qualified_type_name()))? { + if include + != ::parse(Some(condition_input)) + .map_err(|e| e.into_error(pos, bool::qualified_type_name()))? + { return Ok(true); } } @@ -466,8 +477,7 @@ impl<'a> ContextBase<'a, &'a Positioned> { Some(value) => (value.pos, Some(self.resolved_input_value(value)?)), None => (Pos::default(), None), }; - InputValueType::parse(value) - .map_err(|e| e.into_error(pos, T::qualified_type_name())) + InputValueType::parse(value).map_err(|e| e.into_error(pos, T::qualified_type_name())) } /// Get the position of the current field in the query code. diff --git a/src/extensions/logger.rs b/src/extensions/logger.rs index 4d5f6cdf..db7bd8b8 100644 --- a/src/extensions/logger.rs +++ b/src/extensions/logger.rs @@ -1,6 +1,6 @@ use crate::extensions::{Extension, ResolveInfo}; +use crate::parser::types::{Definition, Document, OperationType, Selection}; use crate::{Error, Variables}; -use crate::parser::types::{Definition, Document, Selection, OperationType}; use itertools::Itertools; use log::{error, info, trace}; use std::borrow::Cow; diff --git a/src/extensions/mod.rs b/src/extensions/mod.rs index f9bf6e6b..300124a9 100644 --- a/src/extensions/mod.rs +++ b/src/extensions/mod.rs @@ -10,8 +10,8 @@ use crate::{Result, Variables}; pub use self::apollo_tracing::ApolloTracing; pub use self::logger::Logger; pub use self::tracing::Tracing; -use crate::Error; use crate::parser::types::Document; +use crate::Error; use serde_json::Value; pub(crate) type BoxExtension = Box; diff --git a/src/lib.rs b/src/lib.rs index 1afebf05..90383d9a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -141,7 +141,7 @@ pub use error::{ ParseRequestError, QueryError, ResultExt, RuleError, }; pub use look_ahead::Lookahead; -pub use parser::{Pos, Positioned, types::Value}; +pub use parser::{types::Value, Pos, Positioned}; pub use query::{IntoQueryBuilder, IntoQueryBuilderOpts, QueryBuilder, QueryResponse}; pub use registry::CacheControl; pub use scalars::{Any, Json, OutputJson, ID}; diff --git a/src/look_ahead.rs b/src/look_ahead.rs index 6eeb28cb..e28531d5 100644 --- a/src/look_ahead.rs +++ b/src/look_ahead.rs @@ -37,7 +37,8 @@ fn find<'a>( } } Selection::InlineFragment(inline_fragment) => { - if let Some(field) = find(document, &inline_fragment.node.selection_set.node, name) { + if let Some(field) = find(document, &inline_fragment.node.selection_set.node, name) + { return Some(field); } } diff --git a/src/mutation_resolver.rs b/src/mutation_resolver.rs index 988116fb..674c9378 100644 --- a/src/mutation_resolver.rs +++ b/src/mutation_resolver.rs @@ -136,8 +136,11 @@ fn do_resolve<'a, T: ObjectType + Send + Sync>( continue; } - if let Some(TypeCondition { on: name }) = - inline_fragment.node.type_condition.as_ref().map(|v| &v.node) + if let Some(TypeCondition { on: name }) = inline_fragment + .node + .type_condition + .as_ref() + .map(|v| &v.node) { let mut futures = Vec::new(); root.collect_inline_fields( diff --git a/src/query.rs b/src/query.rs index 4463ffcb..97c0fd31 100644 --- a/src/query.rs +++ b/src/query.rs @@ -2,12 +2,12 @@ use crate::context::{Data, ResolveId}; use crate::error::ParseRequestError; use crate::extensions::{BoxExtension, ErrorLogger, Extension}; use crate::mutation_resolver::do_mutation_resolve; +use crate::parser::types::{OperationType, UploadValue, Value}; use crate::registry::CacheControl; use crate::{ do_resolve, ContextBase, Error, ObjectType, Pos, QueryEnv, QueryError, Result, Schema, SubscriptionType, Variables, }; -use crate::parser::types::{OperationType, Value, UploadValue}; use std::any::Any; use std::fs::File; use std::sync::atomic::AtomicUsize; @@ -143,22 +143,24 @@ impl QueryBuilder { let inc_resolve_id = AtomicUsize::default(); let document = match document.into_executable(self.operation_name.as_deref()) { Some(document) => document, - None => return if let Some(operation_name) = self.operation_name { - Err(Error::Query { - pos: Pos::default(), - path: None, - err: QueryError::UnknownOperationNamed { - name: operation_name, - }, - }) - } else { - Err(Error::Query { - pos: Pos::default(), - path: None, - err: QueryError::MissingOperation, - }) + None => { + return if let Some(operation_name) = self.operation_name { + Err(Error::Query { + pos: Pos::default(), + path: None, + err: QueryError::UnknownOperationNamed { + name: operation_name, + }, + }) + } else { + Err(Error::Query { + pos: Pos::default(), + path: None, + err: QueryError::MissingOperation, + }) + } + .log_error(&extensions) } - .log_error(&extensions), }; let env = QueryEnv::new( diff --git a/src/registry.rs b/src/registry.rs index 18b7a54c..13074cac 100644 --- a/src/registry.rs +++ b/src/registry.rs @@ -1,4 +1,4 @@ -use crate::parser::types::{Type as ParsedType, BaseType as ParsedBaseType}; +use crate::parser::types::{BaseType as ParsedBaseType, Type as ParsedType}; use crate::validators::InputValueValidator; use crate::{model, Any, Type as _, Value}; use indexmap::map::IndexMap; @@ -162,7 +162,11 @@ impl CacheControl { #[must_use] pub fn value(&self) -> Option { if self.max_age > 0 { - Some(format!("max-age={}{}", self.max_age, if self.public { "" } else { ", private" })) + Some(format!( + "max-age={}{}", + self.max_age, + if self.public { "" } else { ", private" } + )) } else { None } diff --git a/src/scalars/json.rs b/src/scalars/json.rs index b38e161f..9c5824c8 100644 --- a/src/scalars/json.rs +++ b/src/scalars/json.rs @@ -1,10 +1,10 @@ +use crate::parser::types::Field; use crate::registry::{MetaType, Registry}; use crate::{ ContextSelectionSet, InputValueResult, OutputValueType, Positioned, Result, ScalarType, Type, Value, }; use async_graphql_derive::Scalar; -use crate::parser::types::Field; use serde::de::DeserializeOwned; use serde::{Deserialize, Serialize}; use std::borrow::Cow; diff --git a/src/scalars/string.rs b/src/scalars/string.rs index e8e04c55..be6e2780 100644 --- a/src/scalars/string.rs +++ b/src/scalars/string.rs @@ -1,9 +1,9 @@ +use crate::parser::types::Field; use crate::{ registry, ContextSelectionSet, InputValueError, InputValueResult, OutputValueType, Positioned, Result, ScalarType, Type, Value, }; use async_graphql_derive::Scalar; -use crate::parser::types::Field; use std::borrow::Cow; /// The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text. diff --git a/src/schema.rs b/src/schema.rs index a10cda68..8cccc930 100644 --- a/src/schema.rs +++ b/src/schema.rs @@ -2,6 +2,7 @@ use crate::context::Data; use crate::extensions::{BoxExtension, ErrorLogger, Extension, Extensions}; use crate::model::__DirectiveLocation; use crate::parser::parse_query; +use crate::parser::types::{Document, OperationType}; use crate::query::QueryBuilder; use crate::registry::{MetaDirective, MetaInputValue, Registry}; use crate::subscription::{create_connection, create_subscription_stream, ConnectionTransport}; @@ -11,7 +12,6 @@ use crate::{ CacheControl, Error, ObjectType, Pos, QueryEnv, QueryError, QueryResponse, Result, SubscriptionType, Type, Variables, ID, }; -use crate::parser::types::{Document, OperationType}; use bytes::Bytes; use futures::channel::mpsc; use futures::Stream; @@ -379,15 +379,17 @@ where let document = match document.into_executable(operation_name) { Some(document) => document, - None => return if let Some(name) = operation_name { - Err(QueryError::UnknownOperationNamed { - name: name.to_string(), + None => { + return if let Some(name) = operation_name { + Err(QueryError::UnknownOperationNamed { + name: name.to_string(), + } + .into_error(Pos::default())) + } else { + Err(QueryError::MissingOperation.into_error(Pos::default())) } - .into_error(Pos::default())) - } else { - Err(QueryError::MissingOperation.into_error(Pos::default())) + .log_error(&extensions) } - .log_error(&extensions), }; if document.operation.node.ty != OperationType::Subscription { diff --git a/src/subscription/subscription_type.rs b/src/subscription/subscription_type.rs index 89e24293..fc2a204a 100644 --- a/src/subscription/subscription_type.rs +++ b/src/subscription/subscription_type.rs @@ -42,19 +42,17 @@ where continue; } match &selection.node { - Selection::Field(field) => { - streams.push( - schema - .subscription - .create_field_stream( - idx, - &ctx.with_field(field), - schema.env.clone(), - environment.clone(), - ) - .await?, - ) - } + Selection::Field(field) => streams.push( + schema + .subscription + .create_field_stream( + idx, + &ctx.with_field(field), + schema.env.clone(), + environment.clone(), + ) + .await?, + ), Selection::FragmentSpread(fragment_spread) => { if let Some(fragment) = ctx .query_env @@ -72,8 +70,11 @@ where } } Selection::InlineFragment(inline_fragment) => { - if let Some(TypeCondition { on: name }) = - inline_fragment.node.type_condition.as_ref().map(|v| &v.node) + if let Some(TypeCondition { on: name }) = inline_fragment + .node + .type_condition + .as_ref() + .map(|v| &v.node) { if name.node == Subscription::type_name() { create_subscription_stream( diff --git a/src/types/connection/connection_type.rs b/src/types/connection/connection_type.rs index 44d5949d..d22081d0 100644 --- a/src/types/connection/connection_type.rs +++ b/src/types/connection/connection_type.rs @@ -1,11 +1,11 @@ use crate::connection::edge::Edge; use crate::connection::page_info::PageInfo; +use crate::parser::types::Field; use crate::types::connection::{CursorType, EmptyFields}; use crate::{ do_resolve, registry, Context, ContextSelectionSet, FieldResult, ObjectType, OutputValueType, Positioned, QueryError, Result, Type, }; -use crate::parser::types::Field; use futures::{Stream, StreamExt, TryStreamExt}; use indexmap::map::IndexMap; use std::borrow::Cow; diff --git a/src/types/connection/edge.rs b/src/types/connection/edge.rs index faa7de62..f8b8816e 100644 --- a/src/types/connection/edge.rs +++ b/src/types/connection/edge.rs @@ -1,10 +1,10 @@ use crate::connection::EmptyFields; +use crate::parser::types::Field; use crate::types::connection::CursorType; use crate::{ do_resolve, registry, Context, ContextSelectionSet, ObjectType, OutputValueType, Positioned, QueryError, Result, Type, }; -use crate::parser::types::Field; use indexmap::map::IndexMap; use std::borrow::Cow; diff --git a/src/types/empty_mutation.rs b/src/types/empty_mutation.rs index 87f14b82..b737ec07 100644 --- a/src/types/empty_mutation.rs +++ b/src/types/empty_mutation.rs @@ -1,8 +1,8 @@ +use crate::parser::types::Field; use crate::{ registry, Context, ContextSelectionSet, Error, ObjectType, OutputValueType, Positioned, QueryError, Result, Type, }; -use crate::parser::types::Field; use std::borrow::Cow; /// Empty mutation diff --git a/src/types/list.rs b/src/types/list.rs index f7f13a51..b805ce02 100644 --- a/src/types/list.rs +++ b/src/types/list.rs @@ -1,8 +1,8 @@ +use crate::parser::types::Field; use crate::{ registry, ContextSelectionSet, InputValueResult, InputValueType, OutputValueType, Positioned, Result, Type, Value, }; -use crate::parser::types::Field; use std::borrow::Cow; impl Type for Vec { diff --git a/src/types/merged_object.rs b/src/types/merged_object.rs index d58df705..406dfd45 100644 --- a/src/types/merged_object.rs +++ b/src/types/merged_object.rs @@ -1,9 +1,9 @@ +use crate::parser::types::Field; use crate::registry::{MetaType, Registry}; use crate::{ do_resolve, CacheControl, Context, ContextSelectionSet, Error, ObjectType, OutputValueType, Positioned, QueryEnv, QueryError, Result, SchemaEnv, SubscriptionType, Type, }; -use crate::parser::types::Field; use futures::Stream; use indexmap::IndexMap; use std::borrow::Cow; diff --git a/src/types/optional.rs b/src/types/optional.rs index fba445a1..e4d303f9 100644 --- a/src/types/optional.rs +++ b/src/types/optional.rs @@ -1,8 +1,8 @@ +use crate::parser::types::Field; use crate::{ registry, ContextSelectionSet, InputValueResult, InputValueType, OutputValueType, Positioned, Result, Type, Value, }; -use crate::parser::types::Field; use std::borrow::Cow; impl Type for Option { diff --git a/src/types/query_root.rs b/src/types/query_root.rs index 9297b162..78078694 100644 --- a/src/types/query_root.rs +++ b/src/types/query_root.rs @@ -1,11 +1,11 @@ use crate::model::{__Schema, __Type}; +use crate::parser::types::Field; use crate::scalars::Any; use crate::{ do_resolve, registry, Context, ContextSelectionSet, Error, ObjectType, OutputValueType, Positioned, QueryError, Result, Type, }; use async_graphql_derive::SimpleObject; -use crate::parser::types::Field; use indexmap::map::IndexMap; use std::borrow::Cow; diff --git a/src/types/upload.rs b/src/types/upload.rs index ad4db887..433c8774 100644 --- a/src/types/upload.rs +++ b/src/types/upload.rs @@ -1,5 +1,5 @@ -use crate::{registry, InputValueError, InputValueResult, InputValueType, Type, Value}; use crate::parser::types::UploadValue; +use crate::{registry, InputValueError, InputValueResult, InputValueType, Type, Value}; use std::borrow::Cow; use std::io::Read; diff --git a/src/validation/rules/arguments_of_correct_type.rs b/src/validation/rules/arguments_of_correct_type.rs index 0fe5f4a1..c5fc2558 100644 --- a/src/validation/rules/arguments_of_correct_type.rs +++ b/src/validation/rules/arguments_of_correct_type.rs @@ -44,9 +44,9 @@ impl<'a> Visitor<'a> for ArgumentsOfCorrectType<'a> { { if let Some(validator) = &arg.validator { let value = match &value.node { - Value::Variable(var_name) => { - ctx.variables.and_then(|variables| variables.0.get(var_name)) - } + Value::Variable(var_name) => ctx + .variables + .and_then(|variables| variables.0.get(var_name)), _ => Some(&value.node), }; diff --git a/src/validation/rules/known_directives.rs b/src/validation/rules/known_directives.rs index a00573d0..2a98774a 100644 --- a/src/validation/rules/known_directives.rs +++ b/src/validation/rules/known_directives.rs @@ -1,6 +1,7 @@ use crate::model::__DirectiveLocation; use crate::parser::types::{ - Directive, Field, FragmentDefinition, FragmentSpread, InlineFragment, OperationDefinition, OperationType + Directive, Field, FragmentDefinition, FragmentSpread, InlineFragment, OperationDefinition, + OperationType, }; use crate::validation::visitor::{Visitor, VisitorContext}; use crate::Positioned; @@ -16,11 +17,12 @@ impl<'a> Visitor<'a> for KnownDirectives { _ctx: &mut VisitorContext<'a>, operation_definition: &'a Positioned, ) { - self.location_stack.push(match &operation_definition.node.ty { - OperationType::Query => __DirectiveLocation::QUERY, - OperationType::Mutation => __DirectiveLocation::MUTATION, - OperationType::Subscription => __DirectiveLocation::SUBSCRIPTION, - }); + self.location_stack + .push(match &operation_definition.node.ty { + OperationType::Query => __DirectiveLocation::QUERY, + OperationType::Mutation => __DirectiveLocation::MUTATION, + OperationType::Subscription => __DirectiveLocation::SUBSCRIPTION, + }); } fn exit_operation_definition( diff --git a/src/validation/rules/known_fragment_names.rs b/src/validation/rules/known_fragment_names.rs index 93f39fa2..f034a813 100644 --- a/src/validation/rules/known_fragment_names.rs +++ b/src/validation/rules/known_fragment_names.rs @@ -14,7 +14,10 @@ impl<'a> Visitor<'a> for KnownFragmentNames { if !ctx.is_known_fragment(&fragment_spread.node.fragment_name.node) { ctx.report_error( vec![fragment_spread.pos], - format!(r#"Unknown fragment: "{}""#, fragment_spread.node.fragment_name.node), + format!( + r#"Unknown fragment: "{}""#, + fragment_spread.node.fragment_name.node + ), ); } } diff --git a/src/validation/rules/known_type_names.rs b/src/validation/rules/known_type_names.rs index 0f51d4b6..d47bde6e 100644 --- a/src/validation/rules/known_type_names.rs +++ b/src/validation/rules/known_type_names.rs @@ -33,8 +33,11 @@ impl<'a> Visitor<'a> for KnownTypeNames { ctx: &mut VisitorContext<'a>, inline_fragment: &'a Positioned, ) { - if let Some(TypeCondition { on: name }) = - inline_fragment.node.type_condition.as_ref().map(|c| &c.node) + if let Some(TypeCondition { on: name }) = inline_fragment + .node + .type_condition + .as_ref() + .map(|c| &c.node) { validate_type(ctx, &name.node, inline_fragment.pos); } diff --git a/src/validation/rules/no_fragment_cycles.rs b/src/validation/rules/no_fragment_cycles.rs index 05616d9f..b7487b01 100644 --- a/src/validation/rules/no_fragment_cycles.rs +++ b/src/validation/rules/no_fragment_cycles.rs @@ -78,7 +78,8 @@ impl<'a> Visitor<'a> for NoFragmentCycles<'a> { fragment_definition: &'a Positioned, ) { self.current_fragment = Some(&fragment_definition.node.name.node); - self.fragment_order.push(&fragment_definition.node.name.node); + self.fragment_order + .push(&fragment_definition.node.name.node); } fn exit_fragment_definition( @@ -98,7 +99,10 @@ impl<'a> Visitor<'a> for NoFragmentCycles<'a> { self.spreads .entry(current_fragment) .or_insert_with(Vec::new) - .push((&fragment_spread.node.fragment_name.node, fragment_spread.pos)); + .push(( + &fragment_spread.node.fragment_name.node, + fragment_spread.pos, + )); } } } diff --git a/src/validation/rules/no_undefined_variables.rs b/src/validation/rules/no_undefined_variables.rs index cde608d2..d70c0f7d 100644 --- a/src/validation/rules/no_undefined_variables.rs +++ b/src/validation/rules/no_undefined_variables.rs @@ -77,7 +77,11 @@ impl<'a> Visitor<'a> for NoUndefinedVariables<'a> { _ctx: &mut VisitorContext<'a>, operation_definition: &'a Positioned, ) { - let name = operation_definition.node.name.as_ref().map(|name| &*name.node); + let name = operation_definition + .node + .name + .as_ref() + .map(|name| &*name.node); self.current_scope = Some(Scope::Operation(name)); self.defined_variables .insert(name, (operation_definition.pos, HashSet::new())); diff --git a/src/validation/rules/no_unused_fragments.rs b/src/validation/rules/no_unused_fragments.rs index 7db4e2c3..8c7e1415 100644 --- a/src/validation/rules/no_unused_fragments.rs +++ b/src/validation/rules/no_unused_fragments.rs @@ -37,7 +37,16 @@ impl<'a> Visitor<'a> for NoUnusedFragments<'a> { for def in &doc.definitions { if let Definition::Operation(operation_definition) = def { - self.find_reachable_fragments(&Scope::Operation(operation_definition.node.name.as_ref().map(|name| &*name.node)), &mut reachable); + self.find_reachable_fragments( + &Scope::Operation( + operation_definition + .node + .name + .as_ref() + .map(|name| &*name.node), + ), + &mut reachable, + ); } } @@ -56,7 +65,13 @@ impl<'a> Visitor<'a> for NoUnusedFragments<'a> { _ctx: &mut VisitorContext<'a>, operation_definition: &'a Positioned, ) { - self.current_scope = Some(Scope::Operation(operation_definition.node.name.as_ref().map(|name| &*name.node))); + self.current_scope = Some(Scope::Operation( + operation_definition + .node + .name + .as_ref() + .map(|name| &*name.node), + )); } fn enter_fragment_definition( @@ -65,10 +80,8 @@ impl<'a> Visitor<'a> for NoUnusedFragments<'a> { fragment_definition: &'a Positioned, ) { self.current_scope = Some(Scope::Fragment(&fragment_definition.node.name.node)); - self.defined_fragments.insert(( - &fragment_definition.node.name.node, - fragment_definition.pos, - )); + self.defined_fragments + .insert((&fragment_definition.node.name.node, fragment_definition.pos)); } fn enter_fragment_spread( diff --git a/src/validation/rules/no_unused_variables.rs b/src/validation/rules/no_unused_variables.rs index a3a4a02f..e7d68a43 100644 --- a/src/validation/rules/no_unused_variables.rs +++ b/src/validation/rules/no_unused_variables.rs @@ -77,7 +77,11 @@ impl<'a> Visitor<'a> for NoUnusedVariables<'a> { _ctx: &mut VisitorContext<'a>, operation_definition: &'a Positioned, ) { - let op_name = operation_definition.node.name.as_ref().map(|name| &*name.node); + let op_name = operation_definition + .node + .name + .as_ref() + .map(|name| &*name.node); self.current_scope = Some(Scope::Operation(op_name)); self.defined_variables.insert(op_name, HashSet::new()); } @@ -97,10 +101,7 @@ impl<'a> Visitor<'a> for NoUnusedVariables<'a> { ) { if let Some(Scope::Operation(ref name)) = self.current_scope { if let Some(vars) = self.defined_variables.get_mut(name) { - vars.insert(( - &variable_definition.node.name.node, - variable_definition.pos, - )); + vars.insert((&variable_definition.node.name.node, variable_definition.pos)); } } } diff --git a/src/validation/rules/overlapping_fields_can_be_merged.rs b/src/validation/rules/overlapping_fields_can_be_merged.rs index 1c5d1550..51115a13 100644 --- a/src/validation/rules/overlapping_fields_can_be_merged.rs +++ b/src/validation/rules/overlapping_fields_can_be_merged.rs @@ -42,7 +42,9 @@ impl<'a, 'ctx> FindConflicts<'a, 'ctx> { self.find(&inline_fragment.node.selection_set); } Selection::FragmentSpread(fragment_spread) => { - if let Some(fragment) = self.ctx.fragment(&fragment_spread.node.fragment_name.node) { + if let Some(fragment) = + self.ctx.fragment(&fragment_spread.node.fragment_name.node) + { self.find(&fragment.node.selection_set); } } diff --git a/src/validation/rules/possible_fragment_spreads.rs b/src/validation/rules/possible_fragment_spreads.rs index a2f9ffeb..4d1d9027 100644 --- a/src/validation/rules/possible_fragment_spreads.rs +++ b/src/validation/rules/possible_fragment_spreads.rs @@ -50,8 +50,11 @@ impl<'a> Visitor<'a> for PossibleFragmentSpreads<'a> { inline_fragment: &'a Positioned, ) { if let Some(parent_type) = ctx.parent_type() { - if let Some(TypeCondition { on: fragment_type }) = - &inline_fragment.node.type_condition.as_ref().map(|c| &c.node) + if let Some(TypeCondition { on: fragment_type }) = &inline_fragment + .node + .type_condition + .as_ref() + .map(|c| &c.node) { if let Some(on_type) = ctx.registry.types.get(&fragment_type.node) { if !parent_type.type_overlap(&on_type) { diff --git a/src/validation/rules/upload_file.rs b/src/validation/rules/upload_file.rs index af46cd8b..75c79ae1 100644 --- a/src/validation/rules/upload_file.rs +++ b/src/validation/rules/upload_file.rs @@ -12,7 +12,10 @@ impl<'a> Visitor<'a> for UploadFile { operation_definition: &'a Positioned, ) { for var in &operation_definition.node.variable_definitions { - if let Some(ty) = ctx.registry.concrete_type_by_parsed_type(&var.node.var_type.node) { + if let Some(ty) = ctx + .registry + .concrete_type_by_parsed_type(&var.node.var_type.node) + { if ty.name() == "Upload" { ctx.report_error( vec![var.pos], diff --git a/src/validation/rules/variables_in_allowed_position.rs b/src/validation/rules/variables_in_allowed_position.rs index 3146569c..1ce06146 100644 --- a/src/validation/rules/variables_in_allowed_position.rs +++ b/src/validation/rules/variables_in_allowed_position.rs @@ -32,12 +32,13 @@ impl<'a> VariableInAllowedPosition<'a> { if let Some(usages) = self.variable_usages.get(from) { for (var_name, usage_pos, var_type) in usages { if let Some(def) = var_defs.iter().find(|def| def.node.name.node == *var_name) { - let expected_type = if def.node.var_type.node.nullable && def.node.default_value.is_some() { - // A nullable type with a default value functions as a non-nullable - format!("{}!", def.node.var_type.node) - } else { - def.node.var_type.node.to_string() - }; + let expected_type = + if def.node.var_type.node.nullable && def.node.default_value.is_some() { + // A nullable type with a default value functions as a non-nullable + format!("{}!", def.node.var_type.node) + } else { + def.node.var_type.node.to_string() + }; if !var_type.is_subtype(&MetaTypeName::create(&expected_type)) { ctx.report_error( @@ -72,7 +73,13 @@ impl<'a> Visitor<'a> for VariableInAllowedPosition<'a> { _ctx: &mut VisitorContext<'a>, operation_definition: &'a Positioned, ) { - self.current_scope = Some(Scope::Operation(operation_definition.node.name.as_ref().map(|name| &*name.node))); + self.current_scope = Some(Scope::Operation( + operation_definition + .node + .name + .as_ref() + .map(|name| &*name.node), + )); } fn enter_fragment_definition( diff --git a/src/validation/test_harness.rs b/src/validation/test_harness.rs index c8d05e4c..4a8b6cd5 100644 --- a/src/validation/test_harness.rs +++ b/src/validation/test_harness.rs @@ -2,9 +2,9 @@ #![allow(dead_code)] #![allow(unreachable_code)] +use crate::parser::types::Document; use crate::validation::visitor::{visit, Visitor, VisitorContext}; use crate::*; -use crate::parser::types::Document; use once_cell::sync::Lazy; #[InputObject(internal)] diff --git a/src/validation/visitor.rs b/src/validation/visitor.rs index 941da344..2af7eebe 100644 --- a/src/validation/visitor.rs +++ b/src/validation/visitor.rs @@ -538,8 +538,11 @@ fn visit_selection<'a, V: Visitor<'a>>( visit_fragment_spread(v, ctx, fragment_spread) } Selection::InlineFragment(inline_fragment) => { - if let Some(TypeCondition { on: name }) = - &inline_fragment.node.type_condition.as_ref().map(|c| &c.node) + if let Some(TypeCondition { on: name }) = &inline_fragment + .node + .type_condition + .as_ref() + .map(|c| &c.node) { ctx.with_type(ctx.registry.types.get(&name.node), |ctx| { visit_inline_fragment(v, ctx, inline_fragment) diff --git a/tests/input_validators.rs b/tests/input_validators.rs index 63ad33bb..bf0ed132 100644 --- a/tests/input_validators.rs +++ b/tests/input_validators.rs @@ -1625,7 +1625,9 @@ pub async fn test_input_validator_variable() { let validator_length = 6; for case in &test_cases { let mut variables = Variables::default(); - variables.0.insert("id".to_string(), Value::String(case.to_string())); + variables + .0 + .insert("id".to_string(), Value::String(case.to_string())); let field_query = "query($id: String!) {fieldParameter(id: $id)}"; let object_query = "query($id: String!) {inputObject(input: {id: $id})}";