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

Merge branch master into rework-core-traits [skip ci]

Browse source
This commit is contained in:
tyranron 2022-08-10 16:39:53 +03:00
commit d8813aff13
No known key found for this signature in database
GPG key ID: 762E144FB230A4F0
311 changed files with 6317 additions and 5657 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
.github/workflows/ci.yml vendored
View file

@ -29,6 +29,7 @@ jobs:
- release-check
- rustfmt
- test
- test-book
- wasm
runs-on: ubuntu-latest
steps:
@ -171,7 +172,6 @@ jobs:
- juniper_graphql_ws
- juniper_integration_tests
- juniper_codegen_tests
- juniper_book_tests
- juniper_actix
- juniper_hyper
- juniper_iron
@ -194,14 +194,6 @@ jobs:
os: macOS
- crate: juniper_codegen_tests
os: windows
- crate: juniper_book_tests
toolchain: beta
- crate: juniper_book_tests
toolchain: nightly
# TODO: LLVM ERROR: out of memory
- crate: juniper_integration_tests
os: windows
runs-on: ${{ matrix.os }}-latest
steps:
- uses: actions/checkout@v3
@ -213,6 +205,34 @@ jobs:
- run: make test.cargo crate=${{ matrix.crate }}
test-book:
name: test Book
strategy:
fail-fast: false
matrix:
os:
- ubuntu
- macOS
# TODO: Re-enable once rust-lang/rust#99466 is fixed:
# https://github.com/rust-lang/rust/issues/99466
#- windows
toolchain:
- stable
- beta
- nightly
runs-on: ${{ matrix.os }}-latest
steps:
- uses: actions/checkout@v3
- uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: ${{ matrix.toolchain }}
override: true
- run: cargo install mdbook
- run: make test.book
wasm:
strategy:
fail-fast: false
@ -281,6 +301,7 @@ jobs:
- package
- rustfmt
- test
- test-book
- wasm
if: ${{ startsWith(github.ref, 'refs/tags/juniper') }}
runs-on: ubuntu-latest
@ -304,7 +325,7 @@ jobs:
- name: Parse CHANGELOG link
id: changelog
run: echo ::set-output
name=LINK::https://github.com/${{ github.repository }}/blob/${{ steps.crate.outputs.NAME }}%40${{ steps.release.outputs.VERSION }}//${{ steps.crate.outputs.NAME }}/CHANGELOG.md#$(sed -n '/^## \[${{ steps.release.outputs.VERSION }}\]/{s/^## \[\(.*\)\][^0-9]*\([0-9].*\)/\1--\2/;s/[^0-9a-z-]*//g;p;}' ${{ steps.crate.outputs.NAME }}/CHANGELOG.md)
name=LINK::${{ github.server_url }}/${{ github.repository }}/blob/${{ steps.crate.outputs.NAME }}%40${{ steps.release.outputs.VERSION }}//${{ steps.crate.outputs.NAME }}/CHANGELOG.md#$(sed -n '/^## \[${{ steps.release.outputs.VERSION }}\]/{s/^## \[\(.*\)\][^0-9]*\([0-9].*\)/\1--\2/;s/[^0-9a-z-]*//g;p;}' ${{ steps.crate.outputs.NAME }}/CHANGELOG.md)
- uses: softprops/action-gh-release@v1
env:
@ -347,19 +368,17 @@ jobs:
deploy-book:
name: deploy Book
needs: ["test"]
needs: ["test", "test-book"]
if: ${{ github.ref == 'refs/heads/master'
|| startsWith(github.ref, 'refs/tags/juniper@') }}
|| startsWith(github.ref, 'refs/tags/juniper@') }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: peaceiris/actions-mdbook@v1
- run: make book.build out=gh-pages/master
if: ${{ github.ref == 'refs/heads/master' }}
- run: make book.build out=gh-pages
if: ${{ startsWith(github.ref, 'refs/tags/juniper@') }}
- run: make book.build out=gh-pages${{ (github.ref == 'refs/heads/master'
&& '/master')
|| '' }}
- name: Deploy to GitHub Pages
uses: peaceiris/actions-gh-pages@v3

13
CONTRIBUTING.md
View file

@ -17,19 +17,16 @@ Before submitting a PR, you should follow these steps to prevent redundant churn
Consistent formatting is enforced on the CI.
Before you submit your PR, you should run `cargo fmt` in the root directory.
Before you submit your PR, you should run `cargo +nightly fmt --all` in the root directory (or use the `make fmt` shortcut).
Formatting should be run on the **stable** compiler.
(You can do `rustup run stable cargo fmt` when developing on nightly)
Formatting should be run on the **nightly** compiler.
### Run all tests
To run all available tests, including verifying the code examples in the book,
you can use [cargo-make](https://github.com/sagiegurari/cargo-make).
To run all available tests, including verifying the code examples in the book:
1. Install cargo-make with `cargo install cargo-make`
2. Run `cargo make ci-flow` in the root directory
(You can do `rustup run nightly cargo make ci-flow` to run all tests when developing on stable)
1. Run `cargo test` in the root directory.
2. Run `make test.book` in the root directory.
### Update the CHANGELOG

1
Cargo.toml
View file

@ -1,7 +1,6 @@
[workspace]
members = [
"benches",
"book/tests",
"examples/basic_subscriptions",
"examples/warp_async",
"examples/warp_subscriptions",

8
Makefile
View file

@ -87,10 +87,14 @@ cargo.test: test.cargo
# Run Rust tests of Book.
#
# Usage:
# make test.book
# make test.book [clean=(no|yes)]
test.book:
@make test.cargo crate=juniper_book_tests
ifeq ($(clean),yes)
cargo clean
endif
cargo build
mdbook test book -L target/debug/deps
# Run Rust tests of project crates.

4
README.md
View file

@ -47,7 +47,7 @@ see the [actix][actix_examples], [hyper][hyper_examples], [rocket][rocket_exampl
## Features
Juniper supports the full GraphQL query language according to the
[specification][graphql_spec], including interfaces, unions, schema
[specification (October 2021)][graphql_spec], including interfaces, unions, schema
introspection, and validations. It can also output the schema in the [GraphQL Schema Language][schema_language].
As an exception to other GraphQL libraries for other languages, Juniper builds
@ -97,7 +97,7 @@ Juniper has not reached 1.0 yet, thus some API instability should be expected.
[graphiql]: https://github.com/graphql/graphiql
[playground]: https://github.com/prisma/graphql-playground
[iron]: https://github.com/iron/iron
[graphql_spec]: http://facebook.github.io/graphql
[graphql_spec]: https://spec.graphql.org/October2021
[schema_language]: https://graphql.org/learn/schema/#type-language
[schema_approach]: https://blog.logrocket.com/code-first-vs-schema-first-development-graphql/
[test_schema_rs]: https://github.com/graphql-rust/juniper/blob/master/juniper/src/tests/fixtures/starwars/schema.rs

2
benches/Cargo.toml
View file

@ -1,7 +1,7 @@
[package]
name = "juniper_benchmarks"
version = "0.0.0"
edition = "2018"
edition = "2021"
authors = ["Christoph Herzog <chris@theduke.at>"]
publish = false

6
benches/benches/benchmark.rs
View file

@ -38,7 +38,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
b.iter(|| {
j::execute_sync(
SYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
vec![("ids".to_owned(), ids.clone())].into_iter().collect(),
)
})
},
@ -58,7 +58,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
b.iter(|| {
let f = j::execute(
ASYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
vec![("ids".to_owned(), ids.clone())].into_iter().collect(),
);
rt.block_on(f)
})
@ -77,7 +77,7 @@ fn bench_sync_vs_async_users_flat_instant(c: &mut Criterion) {
b.iter(|| {
let f = j::execute(
ASYNC_QUERY,
vec![("ids".to_string(), ids.clone())].into_iter().collect(),
vec![("ids".to_owned(), ids.clone())].into_iter().collect(),
);
rt.block_on(f)
})

12
benches/src/lib.rs
View file

@ -11,11 +11,11 @@ pub type QueryResult = Result<
String,
>;
pub struct Context {}
pub struct Context;
impl Context {
fn new() -> Self {
Self {}
Self
}
}
@ -51,8 +51,8 @@ impl User {
Self {
id,
kind: UserKind::Admin,
username: "userx".to_string(),
email: "userx@domain.com".to_string(),
username: "userx".into(),
email: "userx@domain.com".into(),
gender: Some(Gender::Female),
}
}
@ -97,7 +97,7 @@ pub fn new_schema() -> RootNode<'static, Query, EmptyMutation<Context>, EmptySub
pub fn execute_sync(query: &str, vars: Variables) -> QueryResult {
let root = new_schema();
let ctx = Context::new();
juniper::execute_sync(query, None, &root, &vars, &ctx).map_err(|e| format!("{:?}", e))
juniper::execute_sync(query, None, &root, &vars, &ctx).map_err(|e| format!("{e:?}"))
}
pub async fn execute(query: &str, vars: Variables) -> QueryResult {
@ -105,5 +105,5 @@ pub async fn execute(query: &str, vars: Variables) -> QueryResult {
let ctx = Context::new();
juniper::execute(query, None, &root, &vars, &ctx)
.await
.map_err(|e| format!("{:?}", e))
.map_err(|e| format!("{e:?}"))
}

15
book/README.md
View file

@ -47,21 +47,8 @@ The output will be in the `_rendered/` directory.
To run the tests validating all code examples in the book, run:
```bash
cd tests/
cargo test
# or from project root dir:
cargo test -p juniper_book_tests
mdbook test -L ../target/debug/deps
# or via shortcut from project root dir:
make test.book
```
## Test setup
All Rust code examples in the book are compiled on the CI.
This is done using the [skeptic](https://github.com/budziq/rust-skeptic) crate.

2
book/book.toml
View file

@ -13,4 +13,4 @@ create-missing = false
git_repository_url = "https://github.com/graphql-rs/juniper"
[rust]
edition = "2018"
edition = "2021"

4
book/src/README.md
View file

@ -21,7 +21,7 @@ embedded [Graphiql][graphiql] for easy debugging.
## Features
Juniper supports the full GraphQL query language according to the
[specification][graphql_spec], including interfaces, unions, schema
[specification (October 2021)][graphql_spec], including interfaces, unions, schema
introspection, and validations.
It does not, however, support the schema language.
@ -57,7 +57,7 @@ Juniper has not reached 1.0 yet, thus some API instability should be expected.
[graphql]: http://graphql.org
[graphiql]: https://github.com/graphql/graphiql
[iron]: https://github.com/iron/iron
[graphql_spec]: http://facebook.github.io/graphql
[graphql_spec]: https://spec.graphql.org/October2021
[test_schema_rs]: https://github.com/graphql-rust/juniper/blob/master/juniper/src/tests/schema.rs
[tokio]: https://github.com/tokio-rs/tokio
[hyper_examples]: https://github.com/graphql-rust/juniper/tree/master/juniper_hyper/examples

4
book/src/advanced/dataloaders.md
View file

@ -68,7 +68,7 @@ use std::env;
pub fn get_db_conn() -> Connection {
let pg_connection_string = env::var("DATABASE_URI").expect("need a db uri");
println!("Connecting to {}", pg_connection_string);
println!("Connecting to {pg_connection_string}");
let conn = Connection::connect(&pg_connection_string[..], TlsMode::None).unwrap();
println!("Connection is fine");
conn
@ -101,7 +101,7 @@ impl BatchFn<i32, Cult> for CultBatcher {
// A hashmap is used, as we need to return an array which maps each original key to a Cult.
async fn load(&self, keys: &[i32]) -> HashMap<i32, Cult> {
println!("load cult batch {:?}", keys);
println!("load cult batch {keys:?}");
let mut cult_hashmap = HashMap::new();
get_cult_by_ids(&mut cult_hashmap, keys.to_vec());
cult_hashmap

2
book/src/advanced/introspection.md
View file

@ -66,7 +66,7 @@ type Schema = juniper::RootNode<
fn main() {
// Create a context object.
let ctx = Context{};
let ctx = Context;
// Run the built-in introspection query.
let (res, _errors) = juniper::introspect(

11
book/src/advanced/subscriptions.md
View file

@ -25,9 +25,11 @@ This example shows a subscription operation that returns two events, the strings
sequentially:
```rust
# use juniper::{graphql_object, graphql_subscription, FieldError};
# use futures::Stream;
# extern crate futures;
# extern crate juniper;
# use std::pin::Pin;
# use futures::Stream;
# use juniper::{graphql_object, graphql_subscription, FieldError};
#
# #[derive(Clone)]
# pub struct Database;
@ -80,7 +82,6 @@ where [`Connection`][Connection] is a `Stream` of values returned by the operati
# extern crate juniper;
# extern crate juniper_subscriptions;
# extern crate serde_json;
# extern crate tokio;
# use juniper::{
# http::GraphQLRequest,
# graphql_object, graphql_subscription,
@ -98,7 +99,7 @@ where [`Connection`][Connection] is a `Stream` of values returned by the operati
#
# impl Database {
# fn new() -> Self {
# Self {}
# Self
# }
# }
#
@ -126,7 +127,7 @@ where [`Connection`][Connection] is a `Stream` of values returned by the operati
type Schema = RootNode<'static, Query, EmptyMutation<Database>, Subscription>;
fn schema() -> Schema {
Schema::new(Query {}, EmptyMutation::new(), Subscription {})
Schema::new(Query, EmptyMutation::new(), Subscription)
}
async fn run_subscription() {

2
book/src/quickstart.md
View file

@ -130,7 +130,7 @@ impl Mutation {
type Schema = juniper::RootNode<'static, Query, Mutation, EmptySubscription<Context>>;
#
# fn main() {
# let _ = Schema::new(Query, Mutation{}, EmptySubscription::new());
# let _ = Schema::new(Query, Mutation, EmptySubscription::new());
# }
```

2
book/src/servers/iron.md
View file

@ -50,7 +50,7 @@ struct Root;
#[juniper::graphql_object]
impl Root {
fn foo() -> String {
"Bar".to_owned()
"Bar".into()
}
}

6
book/src/types/interfaces.md
View file

@ -227,7 +227,7 @@ impl ObjA {
// ^^ the evaluated program panicked at
// 'Failed to implement interface `Character` on `ObjA`: Field `id`: Argument `isPresent` of type `Boolean!`
// isn't present on the interface and so has to be nullable.'
is_present.then(|| self.id.as_str()).unwrap_or("missing")
is_present.then_some(&self.id).unwrap_or("missing")
}
}
@ -473,9 +473,9 @@ struct Droid {
[1]: https://spec.graphql.org/June2018/#sec-Interfaces
[1]: https://spec.graphql.org/October2021#sec-Interfaces
[2]: https://doc.rust-lang.org/reference/types/trait-object.html
[3]: https://docs.rs/juniper/latest/juniper/trait.ScalarValue.html
[4]: https://docs.rs/juniper/latest/juniper/struct.Executor.html
[5]: https://spec.graphql.org/June2018/#sec-Objects
[5]: https://spec.graphql.org/October2021#sec-Objects
[6]: https://docs.rs/juniper/0.14.2/juniper/trait.Context.html

4
book/src/types/objects/complex_fields.md
View file

@ -157,7 +157,7 @@ They can have custom descriptions and default values.
# extern crate juniper;
# use juniper::graphql_object;
#
struct Person {}
struct Person;
#[graphql_object]
impl Person {
@ -177,7 +177,7 @@ impl Person {
#[graphql(default)]
arg2: i32,
) -> String {
format!("{} {}", arg1, arg2)
format!("{arg1} {arg2}")
}
}
#

20
book/src/types/objects/error_handling.md
View file

@ -60,7 +60,7 @@ there - those errors are automatically converted into `FieldError`.
## Error payloads, `null`, and partial errors
Juniper's error behavior conforms to the [GraphQL specification](https://spec.graphql.org/June2018/#sec-Errors-and-Non-Nullability).
Juniper's error behavior conforms to the [GraphQL specification](https://spec.graphql.org/October2021#sec-Handling-Field-Errors).
When a field returns an error, the field's result is replaced by `null`, an
additional `errors` object is created at the top level of the response, and the
@ -168,7 +168,7 @@ impl Example {
# fn main() {}
```
The specified structured error information is included in the [`extensions`](https://facebook.github.io/graphql/June2018/#sec-Errors) key:
The specified structured error information is included in the [`extensions`](https://spec.graphql.org/October2021#sec-Errors) key:
```json
{
@ -242,15 +242,15 @@ impl Mutation {
if !(10 <= name.len() && name.len() <= 100) {
errors.push(ValidationError {
field: "name".to_string(),
message: "between 10 and 100".to_string()
field: "name".into(),
message: "between 10 and 100".into(),
});
}
if !(1 <= quantity && quantity <= 10) {
errors.push(ValidationError {
field: "quantity".to_string(),
message: "between 1 and 10".to_string()
field: "quantity".into(),
message: "between 1 and 10".into(),
});
}
@ -338,11 +338,11 @@ impl Mutation {
};
if !(10 <= name.len() && name.len() <= 100) {
error.name = Some("between 10 and 100".to_string());
error.name = Some("between 10 and 100".into());
}
if !(1 <= quantity && quantity <= 10) {
error.quantity = Some("between 1 and 10".to_string());
error.quantity = Some("between 1 and 10".into());
}
if error.name.is_none() && error.quantity.is_none() {
@ -436,11 +436,11 @@ impl Mutation {
};
if !(10 <= name.len() && name.len() <= 100) {
error.name = Some("between 10 and 100".to_string());
error.name = Some("between 10 and 100".into());
}
if !(1 <= quantity && quantity <= 10) {
error.quantity = Some("between 1 and 10".to_string());
error.quantity = Some("between 1 and 10".into());
}
if error.name.is_none() && error.quantity.is_none() {

1
book/src/types/objects/using_contexts.md
View file

@ -97,6 +97,7 @@ Context cannot be specified by a mutable reference, because concurrent fields re
For example, when using async runtime with [work stealing][2] (like `tokio`), which obviously requires thread safety in addition, you will need to use a corresponding async version of `RwLock`:
```rust
# extern crate juniper;
# extern crate tokio;
# use std::collections::HashMap;
# use juniper::graphql_object;
use tokio::sync::RwLock;

52
book/src/types/scalars.md
View file

@ -24,10 +24,10 @@ Juniper has built-in support for:
* `String` and `&str` as `String`
* `bool` as `Boolean`
* `juniper::ID` as `ID`. This type is defined [in the
spec](http://facebook.github.io/graphql/#sec-ID) as a type that is serialized
spec](https://spec.graphql.org/October2021#sec-ID) as a type that is serialized
as a string but can be parsed from both a string and an integer.
Note that there is no built-in support for `i64`/`u64`, as the GraphQL spec [doesn't define any built-in scalars for `i64`/`u64` by default](https://spec.graphql.org/June2018/#sec-Int). You may wish to leverage a [custom GraphQL scalar](#custom-scalars) in your schema to support them.
Note that there is no built-in support for `i64`/`u64`, as the GraphQL spec [doesn't define any built-in scalars for `i64`/`u64` by default](https://spec.graphql.org/October2021#sec-Int). You may wish to leverage a [custom GraphQL scalar](#custom-scalars) in your schema to support them.
**Third party types**:
@ -114,6 +114,7 @@ All the methods used from newtype's field can be replaced with attributes:
### `#[graphql(to_output_with = <fn>)]` attribute
```rust
# extern crate juniper;
# use juniper::{GraphQLScalar, ScalarValue, Value};
#
#[derive(GraphQLScalar)]
@ -131,6 +132,7 @@ fn to_output<S: ScalarValue>(v: &Incremented) -> Value<S> {
### `#[graphql(from_input_with = <fn>)]` attribute
```rust
# extern crate juniper;
# use juniper::{GraphQLScalar, InputValue, ScalarValue};
#
#[derive(GraphQLScalar)]
@ -145,14 +147,13 @@ impl UserId {
S: ScalarValue
{
input.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", input))
.ok_or_else(|| format!("Expected `String`, found: {input}"))
.and_then(|str| {
str.strip_prefix("id: ")
.ok_or_else(|| {
format!(
"Expected `UserId` to begin with `id: `, \
found: {}",
input,
found: {input}",
)
})
})
@ -166,6 +167,7 @@ impl UserId {
### `#[graphql(parse_token_with = <fn>]` or `#[graphql(parse_token(<types>)]` attributes
```rust
# extern crate juniper;
# use juniper::{
# GraphQLScalar, InputValue, ParseScalarResult, ParseScalarValue,
# ScalarValue, ScalarToken, Value
@ -190,7 +192,7 @@ where
S: ScalarValue
{
match v {
StringOrInt::String(str) => Value::scalar(str.to_owned()),
StringOrInt::String(s) => Value::scalar(s.to_owned()),
StringOrInt::Int(i) => Value::scalar(*i),
}
}
@ -200,15 +202,12 @@ where
S: ScalarValue
{
v.as_string_value()
.map(|s| StringOrInt::String(s.to_owned()))
.map(|s| StringOrInt::String(s.into()))
.or_else(|| v.as_int_value().map(|i| StringOrInt::Int(i)))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {v}"))
}
fn parse_token<S>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S>
where
S: ScalarValue
{
fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<S> {
<String as ParseScalarValue<S>>::from_str(value)
.or_else(|_| <i32 as ParseScalarValue<S>>::from_str(value))
}
@ -228,6 +227,7 @@ Path can be simply `with = Self` (default path where macro expects resolvers to
in case there is an impl block with custom resolvers:
```rust
# extern crate juniper;
# use juniper::{
# GraphQLScalar, InputValue, ParseScalarResult, ParseScalarValue,
# ScalarValue, ScalarToken, Value
@ -243,7 +243,7 @@ enum StringOrInt {
impl StringOrInt {
fn to_output<S: ScalarValue>(&self) -> Value<S> {
match self {
Self::String(str) => Value::scalar(str.to_owned()),
Self::String(s) => Value::scalar(s.to_owned()),
Self::Int(i) => Value::scalar(*i),
}
}
@ -253,12 +253,12 @@ impl StringOrInt {
S: ScalarValue,
{
v.as_string_value()
.map(|s| Self::String(s.to_owned()))
.map(|s| Self::String(s.into()))
.or_else(|| v.as_int_value().map(Self::Int))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {v}"))
}
fn parse_token<S>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S>
fn parse_token<S>(value: ScalarToken<'_>) -> ParseScalarResult<S>
where
S: ScalarValue,
{
@ -273,6 +273,7 @@ impl StringOrInt {
Or it can be path to a module, where custom resolvers are located.
```rust
# extern crate juniper;
# use juniper::{
# GraphQLScalar, InputValue, ParseScalarResult, ParseScalarValue,
# ScalarValue, ScalarToken, Value
@ -293,7 +294,7 @@ mod string_or_int {
S: ScalarValue,
{
match v {
StringOrInt::String(str) => Value::scalar(str.to_owned()),
StringOrInt::String(s) => Value::scalar(s.to_owned()),
StringOrInt::Int(i) => Value::scalar(*i),
}
}
@ -303,12 +304,12 @@ mod string_or_int {
S: ScalarValue,
{
v.as_string_value()
.map(|s| StringOrInt::String(s.to_owned()))
.map(|s| StringOrInt::String(s.into()))
.or_else(|| v.as_int_value().map(StringOrInt::Int))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {v}"))
}
pub(super) fn parse_token<S>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S>
pub(super) fn parse_token<S>(value: ScalarToken<'_>) -> ParseScalarResult<S>
where
S: ScalarValue,
{
@ -323,6 +324,7 @@ mod string_or_int {
Also, you can partially override `#[graphql(with)]` attribute with other custom scalars.
```rust
# extern crate juniper;
# use juniper::{GraphQLScalar, InputValue, ParseScalarResult, ScalarValue, ScalarToken, Value};
#
#[derive(GraphQLScalar)]
@ -338,7 +340,7 @@ impl StringOrInt {
S: ScalarValue,
{
match self {
Self::String(str) => Value::scalar(str.to_owned()),
Self::String(s) => Value::scalar(s.to_owned()),
Self::Int(i) => Value::scalar(*i),
}
}
@ -348,9 +350,9 @@ impl StringOrInt {
S: ScalarValue,
{
v.as_string_value()
.map(|s| Self::String(s.to_owned()))
.map(|s| Self::String(s.into()))
.or_else(|| v.as_int_value().map(Self::Int))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {v}"))
}
}
#
@ -403,8 +405,8 @@ mod date_scalar {
pub(super) fn from_input(v: &InputValue<CustomScalarValue>) -> Result<Date, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.and_then(|s| s.parse().map_err(|e| format!("Failed to parse `Date`: {}", e)))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| s.parse().map_err(|e| format!("Failed to parse `Date`: {e}")))
}
}
#

6
book/src/types/unions.md
View file

@ -130,7 +130,7 @@ impl Character {
# fn main() {}
```
With an external resolver function we can even declare a new [GraphQL union][1] variant where the Rust type is absent in the initial enum definition. The attribute syntax `#[graphql(on VariantType = resolver_fn)]` follows the [GraphQL syntax for dispatching union variants](https://spec.graphql.org/June2018/#example-f8163).
With an external resolver function we can even declare a new [GraphQL union][1] variant where the Rust type is absent in the initial enum definition. The attribute syntax `#[graphql(on VariantType = resolver_fn)]` follows the [GraphQL syntax for dispatching union variants](https://spec.graphql.org/October2021#example-f8163).
```rust
# #![allow(dead_code)]
@ -485,7 +485,7 @@ enum Character {
[1]: https://spec.graphql.org/June2018/#sec-Unions
[1]: https://spec.graphql.org/October2021#sec-Unions
[2]: https://docs.rs/juniper/latest/juniper/trait.ScalarValue.html
[5]: https://spec.graphql.org/June2018/#sec-Interfaces
[5]: https://spec.graphql.org/October2021#sec-Interfaces
[6]: https://docs.rs/juniper/0.14.2/juniper/trait.Context.html

22
book/tests/Cargo.toml
View file

@ -1,22 +0,0 @@
[package]
name = "juniper_book_tests"
version = "0.0.0"
edition = "2018"
authors = ["Magnus Hallin <mhallin@fastmail.com>"]
publish = false
[dependencies]
derive_more = "0.99"
futures = "0.3"
iron = "0.6"
juniper = { path = "../../juniper" }
juniper_iron = { path = "../../juniper_iron" }
juniper_subscriptions = { path = "../../juniper_subscriptions" }
mount = "0.4"
serde_json = "1.0"
skeptic = "0.13"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "sync"] }
uuid = "1.0"
[build-dependencies]
skeptic = "0.13"

4
book/tests/build.rs
View file

@ -1,4 +0,0 @@
fn main() {
let files = skeptic::markdown_files_of_directory("../src/");
skeptic::generate_doc_tests(&files);
}

3
book/tests/src/lib.rs
View file

@ -1,3 +0,0 @@
#![deny(warnings)]
include!(concat!(env!("OUT_DIR"), "/skeptic-tests.rs"));

3
examples/actix_subscriptions/Cargo.toml
View file

@ -1,7 +1,8 @@
[package]
name = "example_actix_subscriptions"
version = "0.0.0"
edition = "2018"
edition = "2021"
rust-version = "1.62"
authors = ["Mihai Dinculescu <mihai.dinculescu@outlook.com>"]
publish = false

23
examples/actix_subscriptions/src/main.rs
View file

@ -9,9 +9,9 @@ use actix_web::{
};
use juniper::{
graphql_object, graphql_subscription, graphql_value,
graphql_subscription, graphql_value,
tests::fixtures::starwars::schema::{Database, Query},
EmptyMutation, FieldError, RootNode,
EmptyMutation, FieldError, GraphQLObject, RootNode,
};
use juniper_actix::{graphql_handler, playground_handler, subscriptions::subscriptions_handler};
use juniper_graphql_ws::ConnectionConfig;
@ -37,23 +37,12 @@ async fn graphql(
struct Subscription;
#[derive(GraphQLObject)]
struct RandomHuman {
id: String,
name: String,
}
// TODO: remove this when async interfaces are merged
#[graphql_object(context = Database)]
impl RandomHuman {
fn id(&self) -> &str {
&self.id
}
fn name(&self) -> &str {
&self.name
}
}
type RandomHumanStream =
Pin<Box<dyn futures::Stream<Item = Result<RandomHuman, FieldError>> + Send>>;
@ -84,8 +73,8 @@ impl Subscription {
let human = context.get_human(&random_id).unwrap().clone();
yield Ok(RandomHuman {
id: human.id().to_owned(),
name: human.name().unwrap().to_owned(),
id: human.id().into(),
name: human.name().unwrap().into(),
})
}
}
@ -142,7 +131,7 @@ async fn main() -> std::io::Result<()> {
.finish()
}))
})
.bind(format!("{}:{}", "127.0.0.1", 8080))?
.bind("127.0.0.1:8080")?
.run()
.await
}

3
examples/basic_subscriptions/Cargo.toml
View file

@ -1,7 +1,8 @@
[package]
name = "example_basic_subscriptions"
version = "0.0.0"
edition = "2018"
edition = "2021"
rust-version = "1.62"
authors = ["Jordao Rosario <jordao.rosario01@gmail.com>"]
publish = false

4
examples/basic_subscriptions/src/main.rs
View file

@ -16,7 +16,7 @@ impl juniper::Context for Database {}
impl Database {
fn new() -> Self {
Self {}
Self
}
}
@ -45,7 +45,7 @@ impl Subscription {
type Schema = RootNode<'static, Query, EmptyMutation<Database>, Subscription>;
fn schema() -> Schema {
Schema::new(Query {}, EmptyMutation::new(), Subscription {})
Schema::new(Query, EmptyMutation::new(), Subscription)
}
#[tokio::main]

3
examples/warp_async/Cargo.toml
View file

@ -1,7 +1,8 @@
[package]
name = "example_warp_async"
version = "0.0.0"
edition = "2018"
edition = "2021"
rust-version = "1.62"
authors = ["Christoph Herzog <chris@theduke.at>"]
publish = false

3
examples/warp_subscriptions/Cargo.toml
View file

@ -1,7 +1,8 @@
[package]
name = "example_warp_subscriptions"
version = "0.0.0"
edition = "2018"
edition = "2021"
rust-version = "1.62"
publish = false
[dependencies]

12
examples/warp_subscriptions/src/main.rs
View file

@ -12,7 +12,7 @@ use juniper_warp::{playground_filter, subscriptions::serve_graphql_ws};
use warp::{http::Response, Filter};
#[derive(Clone)]
struct Context {}
struct Context;
impl juniper::Context for Context {}
@ -123,7 +123,7 @@ impl Subscription {
yield Ok(User {
id: counter,
kind: UserKind::Admin,
name: "stream user".to_string(),
name: "stream user".into(),
})
}
}
@ -149,11 +149,11 @@ async fn main() {
let homepage = warp::path::end().map(|| {
Response::builder()
.header("content-type", "text/html")
.body("<html><h1>juniper_subscriptions demo</h1><div>visit <a href=\"/playground\">graphql playground</a></html>".to_string())
.body("<html><h1>juniper_subscriptions demo</h1><div>visit <a href=\"/playground\">graphql playground</a></html>")
});
let qm_schema = schema();
let qm_state = warp::any().map(move || Context {});
let qm_state = warp::any().map(|| Context);
let qm_graphql_filter = juniper_warp::make_graphql_filter(qm_schema, qm_state.boxed());
let root_node = Arc::new(schema());
@ -165,10 +165,10 @@ async fn main() {
.map(move |ws: warp::ws::Ws| {
let root_node = root_node.clone();
ws.on_upgrade(move |websocket| async move {
serve_graphql_ws(websocket, root_node, ConnectionConfig::new(Context {}))
serve_graphql_ws(websocket, root_node, ConnectionConfig::new(Context))
.map(|r| {
if let Err(e) = r {
println!("Websocket error: {}", e);
println!("Websocket error: {e}");
}
})
.await

14
juniper/CHANGELOG.md
View file

@ -27,7 +27,7 @@ All user visible changes to `juniper` crate will be documented in this file. Thi
- Removed support for `dyn` attribute argument (interface values as trait objects).
- Removed support for `downcast` attribute argument (custom resolution into implementer types).
- Removed support for `async` trait methods (not required anymore).
- Removed necessity of writing `impl Trait for Type` blocks (interfaces are implemented just by matching their fields now).
- Removed necessity of writing `impl Trait for Type` blocks (interfaces are implemented just by matching their fields now). ([#113])
- Forbade default implementations of non-ignored trait methods.
- Supported coercion of additional `null`able arguments and return sub-typing on implementer.
- Supported `rename_all = "<policy>"` attribute argument influencing all its fields and their arguments. ([#971])
@ -48,6 +48,7 @@ All user visible changes to `juniper` crate will be documented in this file. Thi
- Reworked [`chrono` crate] integration GraphQL scalars according to [graphql-scalars.dev] specs: ([#1010])
- Disabled `chrono` [Cargo feature] by default.
- Removed `scalar-naivetime` [Cargo feature].
- Removed lifetime parameter from `ParseError`, `GraphlQLError`, `GraphQLBatchRequest` and `GraphQLRequest`. ([#1081], [#528])
### Added
@ -71,8 +72,13 @@ All user visible changes to `juniper` crate will be documented in this file. Thi
- Unsupported expressions in `graphql_value!` macro. ([#996], [#503])
- Incorrect GraphQL list coercion rules: `null` cannot be coerced to an `[Int!]!` or `[Int]!`. ([#1004])
- All procedural macros expansion inside `macro_rules!`. ([#1054], [#1051])
- Incorrect input value coercion with defaults. ([#1080], [#1073])
- Incorrect error when explicit `null` provided for `null`able list input parameter. ([#1086], [#1085])
- Stack overflow on nested GraphQL fragments. ([CVE-2022-31173])
[#113]: /../../issues/113
[#503]: /../../issues/503
[#528]: /../../issues/528
[#750]: /../../issues/750
[#798]: /../../issues/798
[#918]: /../../issues/918
@ -100,7 +106,13 @@ All user visible changes to `juniper` crate will be documented in this file. Thi
[#1054]: /../../pull/1054
[#1057]: /../../pull/1057
[#1060]: /../../pull/1060
[#1073]: /../../issues/1073
[#1080]: /../../pull/1080
[#1081]: /../../pull/1081
[#1085]: /../../issues/1085
[#1086]: /../../pull/1086
[ba1ed85b]: /../../commit/ba1ed85b3c3dd77fbae7baf6bc4e693321a94083
[CVE-2022-31173]: /../../security/advisories/GHSA-4rx6-g5vg-5f3j

3
juniper/Cargo.toml
View file

@ -1,7 +1,8 @@
[package]
name = "juniper"
version = "0.16.0-dev"
edition = "2018"
edition = "2021"
rust-version = "1.62"
description = "GraphQL server library."
license = "BSD-2-Clause"
authors = [

71
juniper/src/ast.rs
View file

@ -224,10 +224,10 @@ impl<'a> Type<'a> {
impl<'a> fmt::Display for Type<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Named(n) => write!(f, "{}", n),
Self::NonNullNamed(n) => write!(f, "{}!", n),
Self::List(t, _) => write!(f, "[{}]", t),
Self::NonNullList(t, _) => write!(f, "[{}]!", t),
Self::Named(n) => write!(f, "{n}"),
Self::NonNullNamed(n) => write!(f, "{n}!"),
Self::List(t, _) => write!(f, "[{t}]"),
Self::NonNullList(t, _) => write!(f, "[{t}]!"),
}
}
}
@ -248,12 +248,12 @@ impl<S> InputValue<S> {
/// Construct an enum value.
pub fn enum_value<T: AsRef<str>>(s: T) -> Self {
Self::Enum(s.as_ref().to_owned())
Self::Enum(s.as_ref().into())
}
/// Construct a variable value.
pub fn variable<T: AsRef<str>>(v: T) -> Self {
Self::Variable(v.as_ref().to_owned())
Self::Variable(v.as_ref().into())
}
/// Constructs a [`Spanning::unlocated`] [`InputValue::List`].
@ -295,7 +295,7 @@ impl<S> InputValue<S> {
obj.into_iter()
.map(|(k, v)| {
(
Spanning::unlocated(k.as_ref().to_owned()),
Spanning::unlocated(k.as_ref().into()),
Spanning::unlocated(v),
)
})
@ -308,25 +308,36 @@ impl<S> InputValue<S> {
Self::Object(o)
}
/// Resolve all variables to their values.
/// Resolves all variables of this [`InputValue`] to their actual `values`.
///
/// If a variable is not present in the `values`:
/// - Returns [`None`] in case this is an [`InputValue::Variable`].
/// - Skips field in case of an [`InputValue::Object`] field.
/// - Replaces with an [`InputValue::Null`] in case of an
/// [`InputValue::List`] element.
///
/// This is done, because for an [`InputValue::Variable`] (or an
/// [`InputValue::Object`] field) a default value can be used later, if it's
/// provided. While on contrary, a single [`InputValue::List`] element
/// cannot have a default value.
#[must_use]
pub fn into_const(self, vars: &Variables<S>) -> Self
pub fn into_const(self, values: &Variables<S>) -> Option<Self>
where
S: Clone,
{
match self {
Self::Variable(v) => vars.get(&v).map_or_else(InputValue::null, Clone::clone),
Self::List(l) => Self::List(
Self::Variable(v) => values.get(&v).cloned(),
Self::List(l) => Some(Self::List(
l.into_iter()
.map(|s| s.map(|v| v.into_const(vars)))
.map(|s| s.map(|v| v.into_const(values).unwrap_or_else(Self::null)))
.collect(),
),
Self::Object(o) => Self::Object(
)),
Self::Object(o) => Some(Self::Object(
o.into_iter()
.map(|(sk, sv)| (sk, sv.map(|v| v.into_const(vars))))
.filter_map(|(sk, sv)| sv.and_then(|v| v.into_const(values)).map(|sv| (sk, sv)))
.collect(),
),
v => v,
)),
v => Some(v),
}
}
@ -505,13 +516,13 @@ impl<S: ScalarValue> fmt::Display for InputValue<S> {
Self::Null => write!(f, "null"),
Self::Scalar(s) => {
if let Some(s) = s.as_str() {
write!(f, "\"{}\"", s)
write!(f, "\"{s}\"")
} else {
write!(f, "{}", s)
write!(f, "{s}")
}
}
Self::Enum(v) => write!(f, "{}", v),
Self::Variable(v) => write!(f, "${}", v),
Self::Enum(v) => write!(f, "{v}"),
Self::Variable(v) => write!(f, "${v}"),
Self::List(v) => {
write!(f, "[")?;
for (i, spanning) in v.iter().enumerate() {
@ -626,30 +637,30 @@ mod tests {
#[test]
fn test_input_value_fmt() {
let value: InputValue = graphql_input_value!(null);
assert_eq!(format!("{}", value), "null");
assert_eq!(value.to_string(), "null");
let value: InputValue = graphql_input_value!(123);
assert_eq!(format!("{}", value), "123");
assert_eq!(value.to_string(), "123");
let value: InputValue = graphql_input_value!(12.3);
assert_eq!(format!("{}", value), "12.3");
assert_eq!(value.to_string(), "12.3");
let value: InputValue = graphql_input_value!("FOO");
assert_eq!(format!("{}", value), "\"FOO\"");
assert_eq!(value.to_string(), "\"FOO\"");
let value: InputValue = graphql_input_value!(true);
assert_eq!(format!("{}", value), "true");
assert_eq!(value.to_string(), "true");
let value: InputValue = graphql_input_value!(BAR);
assert_eq!(format!("{}", value), "BAR");
assert_eq!(value.to_string(), "BAR");
let value: InputValue = graphql_input_value!(@baz);
assert_eq!(format!("{}", value), "$baz");
assert_eq!(value.to_string(), "$baz");
let value: InputValue = graphql_input_value!([1, 2]);
assert_eq!(format!("{}", value), "[1, 2]");
assert_eq!(value.to_string(), "[1, 2]");
let value: InputValue = graphql_input_value!({"foo": 1,"bar": 2});
assert_eq!(format!("{}", value), "{foo: 1, bar: 2}");
assert_eq!(value.to_string(), "{foo: 1, bar: 2}");
}
}

2
juniper/src/behavior.rs
View file

@ -88,7 +88,7 @@ where
B1: ?Sized,
B2: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

9
juniper/src/executor/look_ahead.rs
View file

@ -112,12 +112,11 @@ pub struct LookAheadSelection<'a, S: 'a> {
pub(super) children: Vec<ChildSelection<'a, S>>,
}
impl<'a, S> Default for LookAheadSelection<'a, S>
where
S: ScalarValue,
{
// Implemented manually to omit redundant `S: Default` trait bound, imposed by
// `#[derive(Default)]`.
impl<'a, S: 'a> Default for LookAheadSelection<'a, S> {
fn default() -> Self {
LookAheadSelection {
Self {
name: "",
alias: None,
arguments: vec![],

59
juniper/src/executor/mod.rs
View file

@ -312,7 +312,7 @@ where
type Type;
#[doc(hidden)]
fn into(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S>;
fn into_resolvable(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S>;
}
impl<'a, S, T, C> IntoResolvable<'a, S, T, C> for T
@ -323,7 +323,7 @@ where
{
type Type = T;
fn into(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
fn into_resolvable(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
Ok(Some((FromContext::from(ctx), self)))
}
}
@ -336,7 +336,7 @@ where
{
type Type = T;
fn into(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
fn into_resolvable(self, ctx: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
self.map(|v: T| Some((<T::Context as FromContext<C>>::from(ctx), v)))
.map_err(IntoFieldError::into_field_error)
}
@ -349,7 +349,7 @@ where
{
type Type = T;
fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
fn into_resolvable(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S> {
Ok(Some(self))
}
}
@ -362,7 +362,7 @@ where
type Type = T;
#[allow(clippy::type_complexity)]
fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S> {
fn into_resolvable(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S> {
Ok(self.map(|(ctx, v)| (ctx, Some(v))))
}
}
@ -375,7 +375,7 @@ where
{
type Type = T;
fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S2> {
fn into_resolvable(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, T)>, S2> {
self.map(Some).map_err(FieldError::map_scalar_value)
}
}
@ -390,7 +390,7 @@ where
type Type = T;
#[allow(clippy::type_complexity)]
fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S2> {
fn into_resolvable(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S2> {
self.map(|o| o.map(|(ctx, v)| (ctx, Some(v))))
.map_err(FieldError::map_scalar_value)
}
@ -782,7 +782,7 @@ impl<'a> FieldPath<'a> {
FieldPath::Root(_) => (),
FieldPath::Field(name, _, parent) => {
parent.construct_path(acc);
acc.push((*name).to_owned());
acc.push((*name).into());
}
}
}
@ -799,7 +799,7 @@ impl<S> ExecutionError<S> {
pub fn new(location: SourcePosition, path: &[&str], error: FieldError<S>) -> ExecutionError<S> {
ExecutionError {
location,
path: path.iter().map(|s| (*s).to_owned()).collect(),
path: path.iter().map(|s| (*s).into()).collect(),
error,
}
}
@ -822,13 +822,13 @@ impl<S> ExecutionError<S> {
/// Create new `Executor` and start query/mutation execution.
/// Returns `IsSubscription` error if subscription is passed.
pub fn execute_validated_query<'a, 'b, QueryT, MutationT, SubscriptionT, S>(
pub fn execute_validated_query<'b, QueryT, MutationT, SubscriptionT, S>(
document: &'b Document<S>,
operation: &'b Spanning<Operation<S>>,
root_node: &RootNode<QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &QueryT::Context,
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>
where
S: ScalarValue,
QueryT: GraphQLType<S>,
@ -850,10 +850,10 @@ where
defs.item
.items
.iter()
.filter_map(|&(ref name, ref def)| {
.filter_map(|(name, def)| {
def.default_value
.as_ref()
.map(|i| (name.item.to_owned(), i.item.clone()))
.map(|i| (name.item.into(), i.item.clone()))
})
.collect::<HashMap<String, InputValue<S>>>()
});
@ -922,7 +922,7 @@ pub async fn execute_validated_query_async<'a, 'b, QueryT, MutationT, Subscripti
root_node: &RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &QueryT::Context,
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>
where
QueryT: GraphQLTypeAsync<S>,
QueryT::TypeInfo: Sync,
@ -951,7 +951,7 @@ where
.filter_map(|&(ref name, ref def)| {
def.default_value
.as_ref()
.map(|i| (name.item.to_owned(), i.item.clone()))
.map(|i| (name.item.into(), i.item.clone()))
})
.collect::<HashMap<String, InputValue<S>>>()
});
@ -1019,10 +1019,10 @@ where
}
#[doc(hidden)]
pub fn get_operation<'b, 'd, 'e, S>(
pub fn get_operation<'b, 'd, S>(
document: &'b Document<'d, S>,
operation_name: Option<&str>,
) -> Result<&'b Spanning<Operation<'d, S>>, GraphQLError<'e>>
) -> Result<&'b Spanning<Operation<'d, S>>, GraphQLError>
where
S: ScalarValue,
{
@ -1066,7 +1066,7 @@ pub async fn resolve_validated_subscription<
root_node: &'r RootNode<'r, QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &'r QueryT::Context,
) -> Result<(Value<ValuesStream<'r, S>>, Vec<ExecutionError<S>>), GraphQLError<'r>>
) -> Result<(Value<ValuesStream<'r, S>>, Vec<ExecutionError<S>>), GraphQLError>
where
'r: 'exec_ref,
'd: 'r,
@ -1098,7 +1098,7 @@ where
.filter_map(|&(ref name, ref def)| {
def.default_value
.as_ref()
.map(|i| (name.item.to_owned(), i.item.clone()))
.map(|i| (name.item.into(), i.item.clone()))
})
.collect::<HashMap<String, InputValue<S>>>()
});
@ -1180,7 +1180,7 @@ impl<'r, S: 'r> Registry<'r, S> {
if !self.types.contains_key(name) {
self.insert_placeholder(
validated_name.clone(),
Type::NonNullNamed(Cow::Owned(name.to_string())),
Type::NonNullNamed(Cow::Owned(name.into())),
);
let meta = T::meta(info, self);
self.types.insert(validated_name, meta);
@ -1232,7 +1232,7 @@ impl<'r, S: 'r> Registry<'r, S> {
S: ScalarValue,
{
Field {
name: smartstring::SmartString::from(name),
name: name.into(),
description: None,
arguments: None,
field_type: self.get_type::<I>(info),
@ -1250,9 +1250,6 @@ impl<'r, S: 'r> Registry<'r, S> {
}
/// Creates an [`Argument`] with the provided default `value`.
///
/// When called with type `T`, the actual [`Argument`] will be given the
/// type `Option<T>`.
pub fn arg_with_default<T>(
&mut self,
name: &str,
@ -1263,7 +1260,7 @@ impl<'r, S: 'r> Registry<'r, S> {
T: GraphQLType<S> + ToInputValue<S> + FromInputValue<S>,
S: ScalarValue,
{
Argument::new(name, self.get_type::<Option<T>>(info)).default_value(value.to_input_value())
Argument::new(name, self.get_type::<T>(info)).default_value(value.to_input_value())
}
fn insert_placeholder(&mut self, name: Name, of_type: Type<'r>) {
@ -1281,7 +1278,7 @@ impl<'r, S: 'r> Registry<'r, S> {
{
let name = T::name(info).expect("Scalar types must be named. Implement `name()`");
ScalarMeta::new::<T>(Cow::Owned(name.to_string()))
ScalarMeta::new::<T>(Cow::Owned(name.into()))
}
/// Builds a [`ScalarMeta`] information for the specified [`graphql::Type`],
@ -1437,7 +1434,7 @@ impl<'r, S: 'r> Registry<'r, S> {
let mut v = fields.to_vec();
v.push(self.field::<String>("__typename", &()));
ObjectMeta::new(Cow::Owned(name.to_string()), &v)
ObjectMeta::new(Cow::Owned(name.into()), &v)
}
/// Creates an [`EnumMeta`] type out of the provided `values`.
@ -1453,7 +1450,7 @@ impl<'r, S: 'r> Registry<'r, S> {
{
let name = T::name(info).expect("Enum types must be named. Implement `name()`");
EnumMeta::new::<T>(Cow::Owned(name.to_string()), values)
EnumMeta::new::<T>(Cow::Owned(name.into()), values)
}
/// Builds an [`EnumMeta`] information for the specified [`graphql::Type`],
@ -1505,7 +1502,7 @@ impl<'r, S: 'r> Registry<'r, S> {
let mut v = fields.to_vec();
v.push(self.field::<String>("__typename", &()));
InterfaceMeta::new(Cow::Owned(name.to_string()), &v)
InterfaceMeta::new(Cow::Owned(name.into()), &v)
}
/// Creates an [`UnionMeta`] type of the given `types`.
@ -1516,7 +1513,7 @@ impl<'r, S: 'r> Registry<'r, S> {
{
let name = T::name(info).expect("Union types must be named. Implement name()");
UnionMeta::new(Cow::Owned(name.to_string()), types)
UnionMeta::new(Cow::Owned(name.into()), types)
}
/// Creates an [`InputObjectMeta`] type with the given `args`.
@ -1532,6 +1529,6 @@ impl<'r, S: 'r> Registry<'r, S> {
{
let name = T::name(info).expect("Input object types must be named. Implement name()");
InputObjectMeta::new::<T>(Cow::Owned(name.to_string()), args)
InputObjectMeta::new::<T>(Cow::Owned(name.into()), args)
}
}

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

@ -1,5 +1,6 @@
use crate::{
graphql_object, graphql_value, EmptyMutation, EmptySubscription, GraphQLEnum, RootNode, Value,
graphql_object, graphql_value, graphql_vars, EmptyMutation, EmptySubscription, GraphQLEnum,
RootNode, Value,
};
#[derive(GraphQLEnum)]
@ -30,7 +31,7 @@ impl User {
(0..10)
.map(|index| User {
id: index,
name: format!("user{}", index),
name: format!("user{index}"),
kind: UserKind::User,
})
.collect()
@ -55,7 +56,7 @@ impl Query {
}
async fn field_async_plain() -> String {
"field_async_plain".to_string()
"field_async_plain".into()
}
fn user(id: String) -> User {
@ -86,8 +87,7 @@ async fn async_simple() {
}
"#;
let vars = Default::default();
let (res, errs) = crate::execute(doc, None, &schema, &vars, &())
let (res, errs) = crate::execute(doc, None, &schema, &graphql_vars! {}, &())
.await
.unwrap();

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

@ -35,7 +35,7 @@ where
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let obj = result.as_object_value().expect("Result is not an object");

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

@ -22,7 +22,7 @@ struct TestType;
#[crate::graphql_object]
impl TestType {
fn to_string(color: Color) -> String {
format!("Color::{:?}", color)
format!("Color::{color:?}")
}
fn a_color() -> Color {
@ -46,7 +46,7 @@ where
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let obj = result.as_object_value().expect("Result is not an object");

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

@ -96,7 +96,7 @@ mod field_execution {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -180,7 +180,7 @@ mod merge_parallel_fragments {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -288,7 +288,7 @@ mod merge_parallel_inline_fragments {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -355,7 +355,7 @@ mod threads_context_correctly {
&schema,
&vars,
&TestContext {
value: "Context value".to_owned(),
value: "Context value".into(),
},
)
.await
@ -363,7 +363,7 @@ mod threads_context_correctly {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!({"a": "Context value"}));
}
@ -410,7 +410,7 @@ mod dynamic_context_switching {
let res = context
.items
.get(&key)
.ok_or(format!("Could not find key {}", key))
.ok_or(format!("Could not find key {key}"))
.map(|c| (c, ItemRef))?;
Ok(res)
}
@ -420,7 +420,7 @@ mod dynamic_context_switching {
key: i32,
) -> FieldResult<Option<(&InnerContext, ItemRef)>> {
if key > 100 {
Err(format!("Key too large: {}", key))?;
Err(format!("Key too large: {key}"))?;
}
Ok(context.items.get(&key).map(|c| (c, ItemRef)))
}
@ -452,13 +452,13 @@ mod dynamic_context_switching {
(
0,
InnerContext {
value: "First value".to_owned(),
value: "First value".into(),
},
),
(
1,
InnerContext {
value: "Second value".to_owned(),
value: "Second value".into(),
},
),
]
@ -472,7 +472,7 @@ mod dynamic_context_switching {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -500,13 +500,13 @@ mod dynamic_context_switching {
(
0,
InnerContext {
value: "First value".to_owned(),
value: "First value".into(),
},
),
(
1,
InnerContext {
value: "Second value".to_owned(),
value: "Second value".into(),
},
),
]
@ -520,7 +520,7 @@ mod dynamic_context_switching {
assert_eq!(errs, vec![]);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!({"first": {"value": "First value"}}));
}
@ -542,13 +542,13 @@ mod dynamic_context_switching {
(
0,
InnerContext {
value: "First value".to_owned(),
value: "First value".into(),
},
),
(
1,
InnerContext {
value: "Second value".to_owned(),
value: "Second value".into(),
},
),
]
@ -569,7 +569,7 @@ mod dynamic_context_switching {
)],
);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!(null));
}
@ -593,13 +593,13 @@ mod dynamic_context_switching {
(
0,
InnerContext {
value: "First value".to_owned(),
value: "First value".into(),
},
),
(
1,
InnerContext {
value: "Second value".to_owned(),
value: "Second value".into(),
},
),
]
@ -620,7 +620,7 @@ mod dynamic_context_switching {
)],
);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -647,13 +647,13 @@ mod dynamic_context_switching {
(
0,
InnerContext {
value: "First value".to_owned(),
value: "First value".into(),
},
),
(
1,
InnerContext {
value: "Second value".to_owned(),
value: "Second value".into(),
},
),
]
@ -667,7 +667,7 @@ mod dynamic_context_switching {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!({"first": {"value": "First value"}}));
}
@ -752,7 +752,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -783,7 +783,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!(null));
@ -811,7 +811,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!(null));
@ -839,7 +839,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!({"inner": {"nullableField": null}}),);
@ -867,7 +867,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!(null));
@ -895,7 +895,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -926,7 +926,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(result, graphql_value!(null));
@ -954,7 +954,7 @@ mod propagates_errors_to_nullable_fields {
.await
.expect("Execution failed");
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,

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

@ -42,12 +42,12 @@ mod interface {
Schema {
pets: vec![
Dog {
name: "Odie".to_owned(),
name: "Odie".into(),
woofs: true,
}
.into(),
Cat {
name: "Garfield".to_owned(),
name: "Garfield".into(),
meows: false,
}
.into(),
@ -77,7 +77,7 @@ mod interface {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -170,11 +170,11 @@ mod union {
Schema {
pets: vec![
Box::new(Dog {
name: "Odie".to_owned(),
name: "Odie".into(),
woofs: true,
}),
Box::new(Cat {
name: "Garfield".to_owned(),
name: "Garfield".into(),
meows: false,
}),
],
@ -205,7 +205,7 @@ mod union {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,

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

@ -92,7 +92,7 @@ where
F: Fn((&Object<DefaultScalarValue>, &Vec<Value<DefaultScalarValue>>)) -> (),
{
let schema = RootNode::new(
Root {},
Root,
EmptyMutation::<()>::new(),
EmptySubscription::<()>::new(),
);
@ -103,7 +103,7 @@ where
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()

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

@ -76,9 +76,9 @@ struct FieldDescription {
#[derive(GraphQLInputObject, Debug)]
struct FieldWithDefaults {
#[graphql(default = "123")]
#[graphql(default = 123)]
field_one: i32,
#[graphql(default = "456", description = "The second field")]
#[graphql(default = 456, description = "The second field")]
field_two: i32,
}
@ -117,7 +117,7 @@ where
F: Fn(&Object<DefaultScalarValue>, &Vec<Value<DefaultScalarValue>>) -> (),
{
let schema = RootNode::new(
Root {},
Root,
EmptyMutation::<()>::new(),
EmptySubscription::<()>::new(),
);
@ -128,7 +128,7 @@ where
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()
@ -312,7 +312,7 @@ fn derive_derived() {
format!(
"{:?}",
Derive {
field_one: "test".to_owned(),
field_one: "test".into(),
},
),
"Derive { field_one: \"test\" }"
@ -462,6 +462,9 @@ async fn field_with_defaults_introspection() {
name
type {
name
ofType {
name
}
}
defaultValue
}
@ -477,12 +480,12 @@ async fn field_with_defaults_introspection() {
assert_eq!(fields.len(), 2);
assert!(fields.contains(&graphql_value!({
"name": "fieldOne",
"type": {"name": "Int"},
"type": {"name": null, "ofType": {"name": "Int"}},
"defaultValue": "123",
})));
assert!(fields.contains(&graphql_value!({
"name": "fieldTwo",
"type": {"name": "Int"},
"type": {"name": null, "ofType": {"name": "Int"}},
"defaultValue": "456",
})));
})

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

@ -69,7 +69,7 @@ async fn test_execution() {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
assert_eq!(
result,
@ -114,7 +114,7 @@ async fn enum_introspection() {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()
@ -223,7 +223,7 @@ async fn interface_introspection() {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()
@ -355,7 +355,7 @@ async fn object_introspection() {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()
@ -406,7 +406,7 @@ async fn object_introspection() {
assert_eq!(fields.len(), 2);
println!("Fields: {:#?}", fields);
println!("Fields: {fields:#?}");
assert!(fields.contains(&graphql_value!({
"name": "sampleEnum",
@ -444,9 +444,13 @@ async fn object_introspection() {
"name": "second",
"description": "The second number",
"type": {
"name": "Int",
"kind": "SCALAR",
"ofType": null,
"name": null,
"kind": "NON_NULL",
"ofType": {
"name": "Int",
"kind": "SCALAR",
"ofType": null,
},
},
"defaultValue": "123",
}],
@ -493,7 +497,7 @@ async fn scalar_introspection() {
assert_eq!(errs, []);
println!("Result: {:#?}", result);
println!("Result: {result:#?}");
let type_info = result
.as_object_value()

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

@ -23,7 +23,7 @@ impl TestComplexScalar {
v.as_string_value()
.filter(|s| *s == "SerializedValue")
.map(|_| Self)
.ok_or_else(|| format!(r#"Expected "SerializedValue" string, found: {}"#, v))
.ok_or_else(|| format!(r#"Expected "SerializedValue" string, found: {v}"#))
}
}
@ -49,7 +49,7 @@ struct ExampleInputObject {
#[derive(GraphQLInputObject, Debug)]
struct InputWithDefaults {
#[graphql(default = "123")]
#[graphql(default = 123)]
a: i32,
}
@ -58,41 +58,47 @@ struct TestType;
#[graphql_object]
impl TestType {
fn field_with_object_input(input: Option<TestInputObject>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn field_with_nullable_string_input(input: Option<String>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn field_with_non_nullable_string_input(input: String) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn field_with_default_argument_value(
#[graphql(default = "Hello World")] input: String,
) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn nullable_field_with_default_argument_value(
#[graphql(default = "Hello World".to_owned())] input: Option<String>,
) -> String {
format!("{input:?}")
}
fn field_with_nested_object_input(input: Option<TestNestedInputObject>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn list(input: Option<Vec<Option<String>>>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn nn_list(input: Vec<Option<String>>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn list_nn(input: Option<Vec<String>>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn nn_list_nn(input: Vec<String>) -> String {
format!("{:?}", input)
format!("{input:?}")
}
fn example_input(arg: ExampleInputObject) -> String {
@ -104,11 +110,11 @@ impl TestType {
}
fn integer_input(value: i32) -> String {
format!("value: {}", value)
format!("value: {value}")
}
fn float_input(value: f64) -> String {
format!("value: {}", value)
format!("value: {value}")
}
}
@ -128,7 +134,7 @@ where
assert_eq!(errs, []);
println!("Result: {:?}", result);
println!("Result: {result:?}");
let obj = result.as_object_value().expect("Result is not an object");
@ -791,13 +797,14 @@ async fn default_argument_when_not_provided() {
}
#[tokio::test]
async fn default_argument_when_nullable_variable_not_provided() {
run_query(
r#"query q($input: String) { fieldWithDefaultArgumentValue(input: $input) }"#,
async fn provided_variable_overwrites_default_value() {
run_variable_query(
r#"query q($input: String!) { fieldWithDefaultArgumentValue(input: $input) }"#,
graphql_vars! {"input": "Overwritten"},
|result| {
assert_eq!(
result.get_field_value("fieldWithDefaultArgumentValue"),
Some(&graphql_value!(r#""Hello World""#)),
Some(&graphql_value!(r#""Overwritten""#)),
);
},
)
@ -805,14 +812,28 @@ async fn default_argument_when_nullable_variable_not_provided() {
}
#[tokio::test]
async fn default_argument_when_nullable_variable_set_to_null() {
async fn default_argument_when_nullable_variable_not_provided() {
run_query(
r#"query q($input: String) { nullableFieldWithDefaultArgumentValue(input: $input) }"#,
|result| {
assert_eq!(
result.get_field_value("nullableFieldWithDefaultArgumentValue"),
Some(&graphql_value!(r#"Some("Hello World")"#)),
);
},
)
.await;
}
#[tokio::test]
async fn null_when_nullable_variable_of_argument_with_default_value_set_to_null() {
run_variable_query(
r#"query q($input: String) { fieldWithDefaultArgumentValue(input: $input) }"#,
r#"query q($input: String) { nullableFieldWithDefaultArgumentValue(input: $input) }"#,
graphql_vars! {"input": null},
|result| {
assert_eq!(
result.get_field_value("fieldWithDefaultArgumentValue"),
Some(&graphql_value!(r#""Hello World""#)),
result.get_field_value("nullableFieldWithDefaultArgumentValue"),
Some(&graphql_value!(r#"None"#)),
);
},
)

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

@ -60,11 +60,8 @@ where
self.variables
.as_ref()
.and_then(|iv| {
iv.to_object_value().map(|o| {
o.into_iter()
.map(|(k, v)| (k.to_owned(), v.clone()))
.collect()
})
iv.to_object_value()
.map(|o| o.into_iter().map(|(k, v)| (k.into(), v.clone())).collect())
})
.unwrap_or_default()
}
@ -86,11 +83,11 @@ where
///
/// This is a simple wrapper around the `execute_sync` function exposed at the
/// top level of this crate.
pub fn execute_sync<'a, QueryT, MutationT, SubscriptionT>(
&'a self,
root_node: &'a RootNode<QueryT, MutationT, SubscriptionT, S>,
pub fn execute_sync<QueryT, MutationT, SubscriptionT>(
&self,
root_node: &RootNode<QueryT, MutationT, SubscriptionT, S>,
context: &QueryT::Context,
) -> GraphQLResponse<'a, S>
) -> GraphQLResponse<S>
where
S: ScalarValue,
QueryT: GraphQLType<S>,
@ -114,7 +111,7 @@ where
&'a self,
root_node: &'a RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
context: &'a QueryT::Context,
) -> GraphQLResponse<'a, S>
) -> GraphQLResponse<S>
where
QueryT: GraphQLTypeAsync<S>,
QueryT::TypeInfo: Sync,
@ -140,7 +137,7 @@ pub async fn resolve_into_stream<'req, 'rn, 'ctx, 'a, QueryT, MutationT, Subscri
req: &'req GraphQLRequest<S>,
root_node: &'rn RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
context: &'ctx QueryT::Context,
) -> Result<(Value<ValuesStream<'a, S>>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<ValuesStream<'a, S>>, Vec<ExecutionError<S>>), GraphQLError>
where
'req: 'a,
'rn: 'a,
@ -166,16 +163,16 @@ where
/// to JSON and send it over the wire. Use the `is_ok` method to determine
/// whether to send a 200 or 400 HTTP status code.
#[derive(Debug)]
pub struct GraphQLResponse<'a, S = DefaultScalarValue>(
Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>,
pub struct GraphQLResponse<S = DefaultScalarValue>(
Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>,
);
impl<'a, S> GraphQLResponse<'a, S>
impl<S> GraphQLResponse<S>
where
S: ScalarValue,
{
/// Constructs new `GraphQLResponse` using the given result
pub fn from_result(r: Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>) -> Self {
pub fn from_result(r: Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>) -> Self {
Self(r)
}
@ -193,12 +190,11 @@ where
}
}
impl<'a, T> Serialize for GraphQLResponse<'a, T>
impl<T> Serialize for GraphQLResponse<T>
where
T: Serialize + ScalarValue,
Value<T>: Serialize,
ExecutionError<T>: Serialize,
GraphQLError<'a>: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@ -272,7 +268,7 @@ where
&'a self,
root_node: &'a RootNode<QueryT, MutationT, SubscriptionT, S>,
context: &QueryT::Context,
) -> GraphQLBatchResponse<'a, S>
) -> GraphQLBatchResponse<S>
where
QueryT: GraphQLType<S>,
MutationT: GraphQLType<S, Context = QueryT::Context>,
@ -298,7 +294,7 @@ where
&'a self,
root_node: &'a RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
context: &'a QueryT::Context,
) -> GraphQLBatchResponse<'a, S>
) -> GraphQLBatchResponse<S>
where
QueryT: GraphQLTypeAsync<S>,
QueryT::TypeInfo: Sync,
@ -340,20 +336,17 @@ where
/// wheter to send a 200 or 400 HTTP status code.
#[derive(Serialize)]
#[serde(untagged)]
pub enum GraphQLBatchResponse<'a, S = DefaultScalarValue>
pub enum GraphQLBatchResponse<S = DefaultScalarValue>
where
S: ScalarValue,
{
/// Result of a single operation in a GraphQL request.
Single(GraphQLResponse<'a, S>),
Single(GraphQLResponse<S>),
/// Result of a batch operation in a GraphQL request.
Batch(Vec<GraphQLResponse<'a, S>>),
Batch(Vec<GraphQLResponse<S>>),
}
impl<'a, S> GraphQLBatchResponse<'a, S>
where
S: ScalarValue,
{
impl<S: ScalarValue> GraphQLBatchResponse<S> {
/// Returns if all the GraphQLResponse in this operation are ok,
/// you can use it to determine wheter to send a 200 or 400 HTTP status code.
pub fn is_ok(&self) -> bool {
@ -639,20 +632,20 @@ pub mod tests {
"type":"connection_init",
"payload":{}
}"#
.to_owned(),
.into(),
),
WsIntegrationMessage::Expect(
r#"{
"type":"connection_ack"
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT,
),
WsIntegrationMessage::Expect(
r#"{
"type":"ka"
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT,
),
WsIntegrationMessage::Send(
@ -666,7 +659,7 @@ pub mod tests {
"query":"subscription { asyncHuman { id, name, homePlanet } }"
}
}"#
.to_owned(),
.into(),
),
WsIntegrationMessage::Expect(
r#"{
@ -682,7 +675,7 @@ pub mod tests {
}
}
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT,
),
];
@ -692,7 +685,7 @@ pub mod tests {
async fn test_ws_invalid_json<T: WsIntegration>(integration: &T) {
let messages = vec![
WsIntegrationMessage::Send("invalid json".to_owned()),
WsIntegrationMessage::Send("invalid json".into()),
WsIntegrationMessage::Expect(
r#"{
"type":"connection_error",
@ -700,7 +693,7 @@ pub mod tests {
"message":"serde error: expected value at line 1 column 1"
}
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT,
),
];
@ -715,20 +708,20 @@ pub mod tests {
"type":"connection_init",
"payload":{}
}"#
.to_owned(),
.into(),
),
WsIntegrationMessage::Expect(
r#"{
"type":"connection_ack"
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT
),
WsIntegrationMessage::Expect(
r#"{
"type":"ka"
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT
),
WsIntegrationMessage::Send(
@ -742,7 +735,7 @@ pub mod tests {
"query":"subscription { asyncHuman }"
}
}"#
.to_owned(),
.into(),
),
WsIntegrationMessage::Expect(
r#"{
@ -756,7 +749,7 @@ pub mod tests {
}]
}]
}"#
.to_owned(),
.into(),
WS_INTEGRATION_EXPECT_DEFAULT_TIMEOUT
)
];

17
juniper/src/integrations/bigdecimal.rs
View file

@ -32,8 +32,6 @@ use crate::{graphql_scalar, InputValue, ScalarValue, Value};
type BigDecimal = bigdecimal::BigDecimal;
mod bigdecimal_scalar {
use std::convert::TryFrom as _;
use super::*;
pub(super) fn to_output<S: ScalarValue>(v: &BigDecimal) -> Value<S> {
@ -45,13 +43,13 @@ mod bigdecimal_scalar {
Ok(BigDecimal::from(i))
} else if let Some(f) = v.as_float_value() {
BigDecimal::try_from(f)
.map_err(|e| format!("Failed to parse `BigDecimal` from `Float`: {}", e))
.map_err(|e| format!("Failed to parse `BigDecimal` from `Float`: {e}"))
} else {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
BigDecimal::from_str(s)
.map_err(|e| format!("Failed to parse `BigDecimal` from `String`: {}", e))
.map_err(|e| format!("Failed to parse `BigDecimal` from `String`: {e}"))
})
}
}
@ -88,11 +86,10 @@ mod test {
assert!(
parsed.is_ok(),
"failed to parse `{:?}`: {:?}",
input,
"failed to parse `{input:?}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {:?}", input);
assert_eq!(parsed.unwrap(), expected, "input: {input:?}");
}
}
@ -110,7 +107,7 @@ mod test {
let input: InputValue = input;
let parsed = BigDecimal::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -126,7 +123,7 @@ mod test {
] {
let actual: InputValue = BigDecimal::from_str(raw).unwrap().to_input_value();
assert_eq!(actual, graphql_input_value!((raw)), "on value: {}", raw);
assert_eq!(actual, graphql_input_value!((raw)), "on value: {raw}");
}
}
}

10
juniper/src/integrations/bson.rs
View file

@ -14,9 +14,9 @@ mod object_id {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<ObjectId, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
ObjectId::parse_str(s).map_err(|e| format!("Failed to parse `ObjectId`: {}", e))
ObjectId::parse_str(s).map_err(|e| format!("Failed to parse `ObjectId`: {e}"))
})
}
}
@ -30,16 +30,16 @@ mod utc_date_time {
pub(super) fn to_output<S: ScalarValue>(v: &UtcDateTime) -> Value<S> {
Value::scalar(
(*v).try_to_rfc3339_string()
.unwrap_or_else(|e| panic!("failed to format `UtcDateTime` as RFC3339: {}", e)),
.unwrap_or_else(|e| panic!("failed to format `UtcDateTime` as RFC3339: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<UtcDateTime, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
UtcDateTime::parse_rfc3339_str(s)
.map_err(|e| format!("Failed to parse `UtcDateTime`: {}", e))
.map_err(|e| format!("Failed to parse `UtcDateTime`: {e}"))
})
}
}

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

@ -62,9 +62,9 @@ mod date {
S: ScalarValue,
{
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
Date::parse_from_str(s, FORMAT).map_err(|e| format!("Invalid `Date`: {}", e))
Date::parse_from_str(s, FORMAT).map_err(|e| format!("Invalid `Date`: {e}"))
})
}
}
@ -127,7 +127,7 @@ mod local_time {
S: ScalarValue,
{
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
// First, try to parse the most used format.
// At the end, try to parse the full format for the parsing
@ -135,7 +135,7 @@ mod local_time {
LocalTime::parse_from_str(s, FORMAT_NO_MILLIS)
.or_else(|_| LocalTime::parse_from_str(s, FORMAT_NO_SECS))
.or_else(|_| LocalTime::parse_from_str(s, FORMAT))
.map_err(|e| format!("Invalid `LocalTime`: {}", e))
.map_err(|e| format!("Invalid `LocalTime`: {e}"))
})
}
}
@ -166,10 +166,10 @@ mod local_date_time {
S: ScalarValue,
{
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
LocalDateTime::parse_from_str(s, FORMAT)
.map_err(|e| format!("Invalid `LocalDateTime`: {}", e))
.map_err(|e| format!("Invalid `LocalDateTime`: {e}"))
})
}
}
@ -219,10 +219,10 @@ mod date_time {
Tz: TimeZone + FromFixedOffset,
{
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
DateTime::<FixedOffset>::parse_from_rfc3339(s)
.map_err(|e| format!("Invalid `DateTime`: {}", e))
.map_err(|e| format!("Invalid `DateTime`: {e}"))
.map(FromFixedOffset::from_fixed_offset)
})
}
@ -345,11 +345,10 @@ mod date_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -372,7 +371,7 @@ mod date_test {
let input: InputValue = input;
let parsed = Date::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -394,7 +393,7 @@ mod date_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -420,11 +419,10 @@ mod local_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -451,7 +449,7 @@ mod local_time_test {
let input: InputValue = input;
let parsed = LocalTime::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -477,7 +475,7 @@ mod local_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -513,11 +511,10 @@ mod local_date_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -546,7 +543,7 @@ mod local_date_time_test {
let input: InputValue = input;
let parsed = LocalDateTime::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -570,7 +567,7 @@ mod local_date_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -635,11 +632,10 @@ mod date_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -673,7 +669,7 @@ mod date_time_test {
let input: InputValue = input;
let parsed = DateTime::<FixedOffset>::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -703,7 +699,7 @@ mod date_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}

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

@ -34,10 +34,10 @@ mod tz {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<TimeZone, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
s.parse::<TimeZone>()
.map_err(|e| format!("Failed to parse `TimeZone`: {}", e))
.map_err(|e| format!("Failed to parse `TimeZone`: {e}"))
})
}
}

18
juniper/src/integrations/rust_decimal.rs
View file

@ -34,8 +34,6 @@ use crate::{graphql_scalar, InputValue, ScalarValue, Value};
type Decimal = rust_decimal::Decimal;
mod rust_decimal_scalar {
use std::convert::TryFrom as _;
use super::*;
pub(super) fn to_output<S: ScalarValue>(v: &Decimal) -> Value<S> {
@ -46,14 +44,13 @@ mod rust_decimal_scalar {
if let Some(i) = v.as_int_value() {
Ok(Decimal::from(i))
} else if let Some(f) = v.as_float_value() {
Decimal::try_from(f)
.map_err(|e| format!("Failed to parse `Decimal` from `Float`: {}", e))
Decimal::try_from(f).map_err(|e| format!("Failed to parse `Decimal` from `Float`: {e}"))
} else {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
Decimal::from_str(s)
.map_err(|e| format!("Failed to parse `Decimal` from `String`: {}", e))
.map_err(|e| format!("Failed to parse `Decimal` from `String`: {e}"))
})
}
}
@ -84,11 +81,10 @@ mod test {
assert!(
parsed.is_ok(),
"failed to parse `{:?}`: {:?}",
input,
"failed to parse `{input:?}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {:?}", input);
assert_eq!(parsed.unwrap(), expected, "input: {input:?}");
}
}
@ -108,7 +104,7 @@ mod test {
let input: InputValue = input;
let parsed = Decimal::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -117,7 +113,7 @@ mod test {
for raw in ["4.20", "0", "999.999999999", "875533788", "123", "43.44"] {
let actual: InputValue = Decimal::from_str(raw).unwrap().to_input_value();
assert_eq!(actual, graphql_input_value!((raw)), "on value: {}", raw);
assert_eq!(actual, graphql_input_value!((raw)), "on value: {raw}");
}
}
}

14
juniper/src/integrations/serde.rs
View file

@ -1,8 +1,4 @@
use std::{
convert::{TryFrom as _, TryInto as _},
fmt,
marker::PhantomData,
};
use std::{fmt, marker::PhantomData};
use indexmap::IndexMap;
use serde::{
@ -42,7 +38,7 @@ impl<T: Serialize> Serialize for ExecutionError<T> {
}
}
impl<'a> Serialize for GraphQLError<'a> {
impl Serialize for GraphQLError {
fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
#[derive(Serialize)]
struct Helper {
@ -247,11 +243,11 @@ impl Serialize for SourcePosition {
}
}
impl<'a> Serialize for Spanning<ParseError<'a>> {
impl Serialize for Spanning<ParseError> {
fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
let mut map = ser.serialize_map(Some(2))?;
let msg = format!("{}", self.item);
let msg = self.item.to_string();
map.serialize_key("message")?;
map.serialize_value(&msg)?;
@ -396,7 +392,7 @@ mod tests {
#[test]
fn error_extensions() {
let mut obj: Object<DefaultScalarValue> = Object::with_capacity(1);
obj.add_field("foo".to_string(), Value::scalar("bar"));
obj.add_field("foo", Value::scalar("bar"));
assert_eq!(
to_string(&ExecutionError::at_origin(FieldError::new(
"foo error",

76
juniper/src/integrations/time.rs
View file

@ -57,14 +57,14 @@ mod date {
pub(super) fn to_output<S: ScalarValue>(v: &Date) -> Value<S> {
Value::scalar(
v.format(FORMAT)
.unwrap_or_else(|e| panic!("Failed to format `Date`: {}", e)),
.unwrap_or_else(|e| panic!("Failed to format `Date`: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Date, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.and_then(|s| Date::parse(s, FORMAT).map_err(|e| format!("Invalid `Date`: {}", e)))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| Date::parse(s, FORMAT).map_err(|e| format!("Invalid `Date`: {e}")))
}
}
@ -109,13 +109,13 @@ mod local_time {
} else {
v.format(FORMAT)
}
.unwrap_or_else(|e| panic!("Failed to format `LocalTime`: {}", e)),
.unwrap_or_else(|e| panic!("Failed to format `LocalTime`: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<LocalTime, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
// First, try to parse the most used format.
// At the end, try to parse the full format for the parsing
@ -123,7 +123,7 @@ mod local_time {
LocalTime::parse(s, FORMAT_NO_MILLIS)
.or_else(|_| LocalTime::parse(s, FORMAT_NO_SECS))
.or_else(|_| LocalTime::parse(s, FORMAT))
.map_err(|e| format!("Invalid `LocalTime`: {}", e))
.map_err(|e| format!("Invalid `LocalTime`: {e}"))
})
}
}
@ -146,16 +146,15 @@ mod local_date_time {
pub(super) fn to_output<S: ScalarValue>(v: &LocalDateTime) -> Value<S> {
Value::scalar(
v.format(FORMAT)
.unwrap_or_else(|e| panic!("Failed to format `LocalDateTime`: {}", e)),
.unwrap_or_else(|e| panic!("Failed to format `LocalDateTime`: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<LocalDateTime, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
LocalDateTime::parse(s, FORMAT)
.map_err(|e| format!("Invalid `LocalDateTime`: {}", e))
LocalDateTime::parse(s, FORMAT).map_err(|e| format!("Invalid `LocalDateTime`: {e}"))
})
}
}
@ -186,15 +185,15 @@ mod date_time {
Value::scalar(
v.to_offset(UtcOffset::UTC)
.format(&Rfc3339)
.unwrap_or_else(|e| panic!("Failed to format `DateTime`: {}", e)),
.unwrap_or_else(|e| panic!("Failed to format `DateTime`: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<DateTime, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
DateTime::parse(s, &Rfc3339).map_err(|e| format!("Invalid `DateTime`: {}", e))
DateTime::parse(s, &Rfc3339).map_err(|e| format!("Invalid `DateTime`: {e}"))
})
.map(|dt| dt.to_offset(UtcOffset::UTC))
}
@ -228,16 +227,16 @@ mod utc_offset {
pub(super) fn to_output<S: ScalarValue>(v: &UtcOffset) -> Value<S> {
Value::scalar(
v.format(UTC_OFFSET_FORMAT)
.unwrap_or_else(|e| panic!("Failed to format `UtcOffset`: {}", e)),
.unwrap_or_else(|e| panic!("Failed to format `UtcOffset`: {e}")),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<UtcOffset, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
UtcOffset::parse(s, UTC_OFFSET_FORMAT)
.map_err(|e| format!("Invalid `UtcOffset`: {}", e))
.map_err(|e| format!("Invalid `UtcOffset`: {e}"))
})
}
}
@ -261,11 +260,10 @@ mod date_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -288,7 +286,7 @@ mod date_test {
let input: InputValue = input;
let parsed = Date::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -302,7 +300,7 @@ mod date_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -330,11 +328,10 @@ mod local_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -364,7 +361,7 @@ mod local_time_test {
let input: InputValue = input;
let parsed = LocalTime::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -378,7 +375,7 @@ mod local_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -402,11 +399,10 @@ mod local_date_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -437,7 +433,7 @@ mod local_date_time_test {
let input: InputValue = input;
let parsed = LocalDateTime::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -455,7 +451,7 @@ mod local_date_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -490,11 +486,10 @@ mod date_time_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -528,7 +523,7 @@ mod date_time_test {
let input: InputValue = input;
let parsed = DateTime::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -546,7 +541,7 @@ mod date_time_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}
@ -574,11 +569,10 @@ mod utc_offset_test {
assert!(
parsed.is_ok(),
"failed to parse `{}`: {:?}",
raw,
"failed to parse `{raw}`: {:?}",
parsed.unwrap_err(),
);
assert_eq!(parsed.unwrap(), expected, "input: {}", raw);
assert_eq!(parsed.unwrap(), expected, "input: {raw}");
}
}
@ -607,7 +601,7 @@ mod utc_offset_test {
let input: InputValue = input;
let parsed = UtcOffset::from_input_value(&input);
assert!(parsed.is_err(), "allows input: {:?}", input);
assert!(parsed.is_err(), "allows input: {input:?}");
}
}
@ -620,7 +614,7 @@ mod utc_offset_test {
] {
let actual: InputValue = val.to_input_value();
assert_eq!(actual, expected, "on value: {}", val);
assert_eq!(actual, expected, "on value: {val}");
}
}
}

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

@ -14,8 +14,8 @@ mod url_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Url, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.and_then(|s| Url::parse(s).map_err(|e| format!("Failed to parse `Url`: {}", e)))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| Url::parse(s).map_err(|e| format!("Failed to parse `Url`: {e}")))
}
}

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

@ -16,8 +16,8 @@ mod uuid_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Uuid, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.and_then(|s| Uuid::parse_str(s).map_err(|e| format!("Failed to parse `Uuid`: {}", e)))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| Uuid::parse_str(s).map_err(|e| format!("Failed to parse `Uuid`: {e}")))
}
}

9
juniper/src/introspection/mod.rs
View file

@ -5,15 +5,12 @@ pub(crate) const INTROSPECTION_QUERY_WITHOUT_DESCRIPTIONS: &str =
/// The desired GraphQL introspection format for the canonical query
/// (<https://github.com/graphql/graphql-js/blob/90bd6ff72625173dd39a1f82cfad9336cfad8f65/src/utilities/getIntrospectionQuery.ts#L62>)
#[derive(Clone, Copy, Debug, Default)]
pub enum IntrospectionFormat {
/// The canonical GraphQL introspection query.
#[default]
All,
/// The canonical GraphQL introspection query without descriptions.
WithoutDescriptions,
}
impl Default for IntrospectionFormat {
fn default() -> Self {
IntrospectionFormat::All
}
}

55
juniper/src/lib.rs
View file

@ -6,6 +6,7 @@
// Required for using `juniper_codegen` macros inside this crate to resolve
// absolute `::juniper` path correctly, without errors.
extern crate core;
extern crate self as juniper;
use std::fmt;
@ -98,8 +99,8 @@ pub use crate::{
/// An error that prevented query execution
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub enum GraphQLError<'a> {
ParseError(Spanning<ParseError<'a>>),
pub enum GraphQLError {
ParseError(Spanning<ParseError>),
ValidationError(Vec<RuleError>),
NoOperationProvided,
MultipleOperationsProvided,
@ -108,26 +109,38 @@ pub enum GraphQLError<'a> {
NotSubscription,
}
impl<'a> fmt::Display for GraphQLError<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl fmt::Display for GraphQLError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
GraphQLError::ParseError(error) => write!(f, "{}", error),
GraphQLError::ValidationError(errors) => {
for error in errors {
writeln!(f, "{}", error)?;
Self::ParseError(e) => write!(f, "{e}"),
Self::ValidationError(errs) => {
for e in errs {
writeln!(f, "{e}")?;
}
Ok(())
}
GraphQLError::NoOperationProvided => write!(f, "No operation provided"),
GraphQLError::MultipleOperationsProvided => write!(f, "Multiple operations provided"),
GraphQLError::UnknownOperationName => write!(f, "Unknown operation name"),
GraphQLError::IsSubscription => write!(f, "Operation is a subscription"),
GraphQLError::NotSubscription => write!(f, "Operation is not a subscription"),
Self::NoOperationProvided => write!(f, "No operation provided"),
Self::MultipleOperationsProvided => write!(f, "Multiple operations provided"),
Self::UnknownOperationName => write!(f, "Unknown operation name"),
Self::IsSubscription => write!(f, "Operation is a subscription"),
Self::NotSubscription => write!(f, "Operation is not a subscription"),
}
}
}
impl<'a> std::error::Error for GraphQLError<'a> {}
impl std::error::Error for GraphQLError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::ParseError(e) => Some(e),
Self::ValidationError(errs) => Some(errs.first()?),
Self::NoOperationProvided
| Self::MultipleOperationsProvided
| Self::UnknownOperationName
| Self::IsSubscription
| Self::NotSubscription => None,
}
}
}
/// Execute a query synchronously in a provided schema
pub fn execute_sync<'a, S, QueryT, MutationT, SubscriptionT>(
@ -136,7 +149,7 @@ pub fn execute_sync<'a, S, QueryT, MutationT, SubscriptionT>(
root_node: &'a RootNode<QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &QueryT::Context,
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>
where
S: ScalarValue,
QueryT: GraphQLType<S>,
@ -175,7 +188,7 @@ pub async fn execute<'a, S, QueryT, MutationT, SubscriptionT>(
root_node: &'a RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &QueryT::Context,
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>
where
QueryT: GraphQLTypeAsync<S>,
QueryT::TypeInfo: Sync,
@ -219,7 +232,7 @@ pub async fn resolve_into_stream<'a, S, QueryT, MutationT, SubscriptionT>(
root_node: &'a RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
variables: &Variables<S>,
context: &'a QueryT::Context,
) -> Result<(Value<ValuesStream<'a, S>>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<ValuesStream<'a, S>>, Vec<ExecutionError<S>>), GraphQLError>
where
QueryT: GraphQLTypeAsync<S>,
QueryT::TypeInfo: Sync,
@ -262,7 +275,7 @@ pub fn introspect<'a, S, QueryT, MutationT, SubscriptionT>(
root_node: &'a RootNode<QueryT, MutationT, SubscriptionT, S>,
context: &QueryT::Context,
format: IntrospectionFormat,
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError<'a>>
) -> Result<(Value<S>, Vec<ExecutionError<S>>), GraphQLError>
where
S: ScalarValue,
QueryT: GraphQLType<S>,
@ -281,8 +294,8 @@ where
)
}
impl<'a> From<Spanning<ParseError<'a>>> for GraphQLError<'a> {
fn from(f: Spanning<ParseError<'a>>) -> GraphQLError<'a> {
GraphQLError::ParseError(f)
impl From<Spanning<ParseError>> for GraphQLError {
fn from(err: Spanning<ParseError>) -> Self {
Self::ParseError(err)
}
}

100
juniper/src/macros/graphql_vars.rs
View file

@ -222,37 +222,35 @@ mod tests {
assert_eq!(
vars! {"key": 123},
vec![("key".to_owned(), IV::scalar(123))]
vec![("key".into(), IV::scalar(123))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": "val"},
vec![("key".to_owned(), IV::scalar("val"))]
vec![("key".into(), IV::scalar("val"))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": 1.23},
vec![("key".to_owned(), IV::scalar(1.23))]
vec![("key".into(), IV::scalar(1.23))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": 1 + 2},
vec![("key".to_owned(), IV::scalar(3))]
.into_iter()
.collect(),
vec![("key".into(), IV::scalar(3))].into_iter().collect(),
);
assert_eq!(
vars! {"key": false},
vec![("key".to_owned(), IV::scalar(false))]
vec![("key".into(), IV::scalar(false))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": (val)},
vec![("key".to_owned(), IV::scalar(42))]
vec![("key".into(), IV::scalar(42))]
.into_iter()
.collect::<V>(),
);
@ -262,13 +260,13 @@ mod tests {
fn r#enum() {
assert_eq!(
vars! {"key": ENUM},
vec![("key".to_owned(), IV::enum_value("ENUM"))]
vec![("key".into(), IV::enum_value("ENUM"))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": lowercase},
vec![("key".to_owned(), IV::enum_value("lowercase"))]
vec![("key".into(), IV::enum_value("lowercase"))]
.into_iter()
.collect::<V>(),
);
@ -278,19 +276,19 @@ mod tests {
fn variable() {
assert_eq!(
vars! {"key": @var},
vec![("key".to_owned(), IV::variable("var"))]
vec![("key".into(), IV::variable("var"))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": @array},
vec![("key".to_owned(), IV::variable("array"))]
vec![("key".into(), IV::variable("array"))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": @object},
vec![("key".to_owned(), IV::variable("object"))]
vec![("key".into(), IV::variable("object"))]
.into_iter()
.collect::<V>(),
);
@ -302,68 +300,65 @@ mod tests {
assert_eq!(
vars! {"key": []},
vec![("key".to_owned(), IV::list(vec![]))]
vec![("key".into(), IV::list(vec![]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [null]},
vec![("key".to_owned(), IV::list(vec![IV::Null]))]
vec![("key".into(), IV::list(vec![IV::Null]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [1]},
vec![("key".to_owned(), IV::list(vec![IV::scalar(1)]))]
vec![("key".into(), IV::list(vec![IV::scalar(1)]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [1 + 2]},
vec![("key".to_owned(), IV::list(vec![IV::scalar(3)]))]
vec![("key".into(), IV::list(vec![IV::scalar(3)]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [(val)]},
vec![("key".to_owned(), IV::list(vec![IV::scalar(42)]))]
vec![("key".into(), IV::list(vec![IV::scalar(42)]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [ENUM]},
vec![("key".to_owned(), IV::list(vec![IV::enum_value("ENUM")]))]
vec![("key".into(), IV::list(vec![IV::enum_value("ENUM")]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [lowercase]},
vec![(
"key".to_owned(),
IV::list(vec![IV::enum_value("lowercase")])
)]
.into_iter()
.collect::<V>(),
vec![("key".into(), IV::list(vec![IV::enum_value("lowercase")]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [@var]},
vec![("key".to_owned(), IV::list(vec![IV::variable("var")]))]
vec![("key".into(), IV::list(vec![IV::variable("var")]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [@array]},
vec![("key".to_owned(), IV::list(vec![IV::variable("array")]))]
vec![("key".into(), IV::list(vec![IV::variable("array")]))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": [@object]},
vec![("key".to_owned(), IV::list(vec![IV::variable("object")]))]
vec![("key".into(), IV::list(vec![IV::variable("object")]))]
.into_iter()
.collect::<V>(),
);
@ -371,7 +366,7 @@ mod tests {
assert_eq!(
vars! {"key": [1, [2], 3]},
vec![(
"key".to_owned(),
"key".into(),
IV::list(vec![
IV::scalar(1),
IV::list(vec![IV::scalar(2)]),
@ -384,7 +379,7 @@ mod tests {
assert_eq!(
vars! {"key": [1, [2 + 3], 3]},
vec![(
"key".to_owned(),
"key".into(),
IV::list(vec![
IV::scalar(1),
IV::list(vec![IV::scalar(5)]),
@ -397,7 +392,7 @@ mod tests {
assert_eq!(
vars! {"key": [1, [ENUM], (val)]},
vec![(
"key".to_owned(),
"key".into(),
IV::list(vec![
IV::scalar(1),
IV::list(vec![IV::enum_value("ENUM")]),
@ -410,7 +405,7 @@ mod tests {
assert_eq!(
vars! {"key": [1 + 2, [(val)], @val]},
vec![(
"key".to_owned(),
"key".into(),
IV::list(vec![
IV::scalar(3),
IV::list(vec![IV::scalar(42)]),
@ -423,7 +418,7 @@ mod tests {
assert_eq!(
vars! {"key": [1, [@val], ENUM]},
vec![(
"key".to_owned(),
"key".into(),
IV::list(vec![
IV::scalar(1),
IV::list(vec![IV::variable("val")]),
@ -441,14 +436,14 @@ mod tests {
assert_eq!(
vars! {"key": {}},
vec![("key".to_owned(), IV::object(IndexMap::<String, _>::new()))]
vec![("key".into(), IV::object(IndexMap::<String, _>::new()))]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": {"key": null}},
vec![("key".to_owned(), IV::object(indexmap! {"key" => IV::Null}))]
vec![("key".into(), IV::object(indexmap! {"key" => IV::Null}))]
.into_iter()
.collect::<V>(),
);
@ -456,7 +451,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": 123}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::scalar(123)}),
)]
.into_iter()
@ -464,17 +459,14 @@ mod tests {
);
assert_eq!(
vars! {"key": {"key": 1 + 2}},
vec![(
"key".to_owned(),
IV::object(indexmap! {"key" => IV::scalar(3)}),
)]
.into_iter()
.collect::<V>(),
vec![("key".into(), IV::object(indexmap! {"key" => IV::scalar(3)}),)]
.into_iter()
.collect::<V>(),
);
assert_eq!(
vars! {"key": {"key": (val)}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::scalar(42)}),
)]
.into_iter()
@ -484,7 +476,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": []}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::list(vec![])}),
)]
.into_iter()
@ -493,7 +485,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": [null]}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::list(vec![IV::Null])}),
)]
.into_iter()
@ -502,7 +494,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": [1]}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::list(vec![IV::scalar(1)])}),
)]
.into_iter()
@ -511,7 +503,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": [1 + 2]}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::list(vec![IV::scalar(3)])}),
)]
.into_iter()
@ -520,7 +512,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": [(val)]}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::list(vec![IV::scalar(42)])}),
)]
.into_iter()
@ -529,7 +521,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": ENUM}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::enum_value("ENUM")}),
)]
.into_iter()
@ -538,7 +530,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": lowercase}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::enum_value("lowercase")}),
)]
.into_iter()
@ -547,7 +539,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": @val}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::variable("val")}),
)]
.into_iter()
@ -556,7 +548,7 @@ mod tests {
assert_eq!(
vars! {"key": {"key": @array}},
vec![(
"key".to_owned(),
"key".into(),
IV::object(indexmap! {"key" => IV::variable("array")}),
)]
.into_iter()
@ -581,7 +573,7 @@ mod tests {
},
vec![
(
"inner".to_owned(),
"inner".into(),
IV::object(indexmap! {
"key1" => IV::scalar(42),
"key2" => IV::scalar("val"),
@ -607,7 +599,7 @@ mod tests {
]),
}),
),
("more".to_owned(), IV::variable("var")),
("more".into(), IV::variable("var")),
]
.into_iter()
.collect::<V>(),

3
juniper/src/macros/helper/mod.rs
View file

@ -41,8 +41,7 @@ where
/// [`GraphQLType::name`]: crate::GraphQLType::name
pub fn err_unnamed_type<S>(name: &str) -> FieldError<S> {
FieldError::from(format!(
"Expected `{}` type to implement `GraphQLType::name`",
name,
"Expected `{name}` type to implement `GraphQLType::name`",
))
}

49
juniper/src/parser/document.rs
View file

@ -22,7 +22,7 @@ use crate::{
pub fn parse_document_source<'a, 'b, S>(
s: &'a str,
schema: &'b SchemaType<'b, S>,
) -> UnlocatedParseResult<'a, OwnedDocument<'a, S>>
) -> UnlocatedParseResult<OwnedDocument<'a, S>>
where
S: ScalarValue,
{
@ -34,7 +34,7 @@ where
fn parse_document<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> UnlocatedParseResult<'a, OwnedDocument<'a, S>>
) -> UnlocatedParseResult<OwnedDocument<'a, S>>
where
S: ScalarValue,
{
@ -52,7 +52,7 @@ where
fn parse_definition<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> UnlocatedParseResult<'a, Definition<'a, S>>
) -> UnlocatedParseResult<Definition<'a, S>>
where
S: ScalarValue,
{
@ -66,14 +66,14 @@ where
Token::Name("fragment") => Ok(Definition::Fragment(parse_fragment_definition(
parser, schema,
)?)),
_ => Err(parser.next_token()?.map(ParseError::UnexpectedToken)),
_ => Err(parser.next_token()?.map(ParseError::unexpected_token)),
}
}
fn parse_operation_definition<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> ParseResult<'a, Operation<'a, S>>
) -> ParseResult<Operation<'a, S>>
where
S: ScalarValue,
{
@ -129,7 +129,7 @@ where
fn parse_fragment_definition<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> ParseResult<'a, Fragment<'a, S>>
) -> ParseResult<Fragment<'a, S>>
where
S: ScalarValue,
{
@ -139,7 +139,7 @@ where
let name = match parser.expect_name() {
Ok(n) => {
if n.item == "on" {
return Err(n.map(|_| ParseError::UnexpectedToken(Token::Name("on"))));
return Err(n.map(|_| ParseError::UnexpectedToken("on".into())));
} else {
n
}
@ -174,7 +174,7 @@ fn parse_optional_selection_set<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
fields: Option<&[&MetaField<'b, S>]>,
) -> OptionParseResult<'a, Vec<Selection<'a, S>>>
) -> OptionParseResult<Vec<Selection<'a, S>>>
where
S: ScalarValue,
{
@ -189,7 +189,7 @@ fn parse_selection_set<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
fields: Option<&[&MetaField<'b, S>]>,
) -> ParseResult<'a, Vec<Selection<'a, S>>>
) -> ParseResult<Vec<Selection<'a, S>>>
where
S: ScalarValue,
{
@ -204,7 +204,7 @@ fn parse_selection<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
fields: Option<&[&MetaField<'b, S>]>,
) -> UnlocatedParseResult<'a, Selection<'a, S>>
) -> UnlocatedParseResult<Selection<'a, S>>
where
S: ScalarValue,
{
@ -218,7 +218,7 @@ fn parse_fragment<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
fields: Option<&[&MetaField<'b, S>]>,
) -> UnlocatedParseResult<'a, Selection<'a, S>>
) -> UnlocatedParseResult<Selection<'a, S>>
where
S: ScalarValue,
{
@ -292,7 +292,7 @@ where
},
)))
}
_ => Err(parser.next_token()?.map(ParseError::UnexpectedToken)),
_ => Err(parser.next_token()?.map(ParseError::unexpected_token)),
}
}
@ -300,7 +300,7 @@ fn parse_field<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
fields: Option<&[&MetaField<'b, S>]>,
) -> ParseResult<'a, Field<'a, S>>
) -> ParseResult<Field<'a, S>>
where
S: ScalarValue,
{
@ -351,7 +351,7 @@ fn parse_arguments<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
arguments: Option<&[Argument<'b, S>]>,
) -> OptionParseResult<'a, Arguments<'a, S>>
) -> OptionParseResult<Arguments<'a, S>>
where
S: ScalarValue,
{
@ -376,7 +376,7 @@ fn parse_argument<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
arguments: Option<&[Argument<'b, S>]>,
) -> ParseResult<'a, (Spanning<&'a str>, Spanning<InputValue<S>>)>
) -> ParseResult<(Spanning<&'a str>, Spanning<InputValue<S>>)>
where
S: ScalarValue,
{
@ -395,21 +395,21 @@ where
))
}
fn parse_operation_type<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, OperationType> {
fn parse_operation_type(parser: &mut Parser<'_>) -> ParseResult<OperationType> {
match parser.peek().item {
Token::Name("query") => Ok(parser.next_token()?.map(|_| OperationType::Query)),
Token::Name("mutation") => Ok(parser.next_token()?.map(|_| OperationType::Mutation)),
Token::Name("subscription") => {
Ok(parser.next_token()?.map(|_| OperationType::Subscription))
}
_ => Err(parser.next_token()?.map(ParseError::UnexpectedToken)),
_ => Err(parser.next_token()?.map(ParseError::unexpected_token)),
}
}
fn parse_variable_definitions<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> OptionParseResult<'a, VariableDefinitions<'a, S>>
) -> OptionParseResult<VariableDefinitions<'a, S>>
where
S: ScalarValue,
{
@ -433,7 +433,7 @@ where
fn parse_variable_definition<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> ParseResult<'a, (Spanning<&'a str>, VariableDefinition<'a, S>)>
) -> ParseResult<(Spanning<&'a str>, VariableDefinition<'a, S>)>
where
S: ScalarValue,
{
@ -473,7 +473,7 @@ where
fn parse_directives<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> OptionParseResult<'a, Vec<Spanning<Directive<'a, S>>>>
) -> OptionParseResult<Vec<Spanning<Directive<'a, S>>>>
where
S: ScalarValue,
{
@ -492,7 +492,7 @@ where
fn parse_directive<'a, 'b, S>(
parser: &mut Parser<'a>,
schema: &'b SchemaType<'b, S>,
) -> ParseResult<'a, Directive<'a, S>>
) -> ParseResult<Directive<'a, S>>
where
S: ScalarValue,
{
@ -516,7 +516,7 @@ where
))
}
pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Type<'a>> {
pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<Type<'a>> {
let parsed_type = if let Some(Spanning {
start: start_pos, ..
}) = parser.skip(&Token::BracketOpen)?
@ -541,10 +541,7 @@ pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Type<'a>> {
})
}
fn wrap_non_null<'a>(
parser: &mut Parser<'a>,
inner: Spanning<Type<'a>>,
) -> ParseResult<'a, Type<'a>> {
fn wrap_non_null<'a>(parser: &mut Parser<'a>, inner: Spanning<Type<'a>>) -> ParseResult<Type<'a>> {
let Spanning { end: end_pos, .. } = parser.expect(&Token::ExclamationMark)?;
let wrapped = match inner.item {

26
juniper/src/parser/lexer.rs
View file

@ -239,7 +239,7 @@ impl<'a> Lexer<'a> {
c if escaped => {
return Err(Spanning::zero_width(
&old_pos,
LexerError::UnknownEscapeSequence(format!("\\{}", c)),
LexerError::UnknownEscapeSequence(format!("\\{c}")),
));
}
'\\' => escaped = true,
@ -305,14 +305,14 @@ impl<'a> Lexer<'a> {
if len != 4 {
return Err(Spanning::zero_width(
start_pos,
LexerError::UnknownEscapeSequence("\\u".to_owned() + escape),
LexerError::UnknownEscapeSequence(format!("\\u{escape}")),
));
}
let code_point = u32::from_str_radix(escape, 16).map_err(|_| {
Spanning::zero_width(
start_pos,
LexerError::UnknownEscapeSequence("\\u".to_owned() + escape),
LexerError::UnknownEscapeSequence(format!("\\u{escape}")),
)
})?;
@ -338,7 +338,7 @@ impl<'a> Lexer<'a> {
let mut end_idx = loop {
if let Some((idx, ch)) = self.peek_char() {
if ch.is_digit(10) || (ch == '-' && last_idx == start_idx) {
if ch.is_ascii_digit() || (ch == '-' && last_idx == start_idx) {
if ch == '0' && last_char == '0' && last_idx == start_idx {
return Err(Spanning::zero_width(
&self.position,
@ -367,7 +367,7 @@ impl<'a> Lexer<'a> {
self.next_char();
end_idx = loop {
if let Some((idx, ch)) = self.peek_char() {
if ch.is_digit(10) {
if ch.is_ascii_digit() {
self.next_char();
} else if last_idx == start_idx {
return Err(Spanning::zero_width(
@ -396,7 +396,9 @@ impl<'a> Lexer<'a> {
end_idx = loop {
if let Some((idx, ch)) = self.peek_char() {
if ch.is_digit(10) || (last_idx == start_idx && (ch == '-' || ch == '+')) {
if ch.is_ascii_digit()
|| (last_idx == start_idx && (ch == '-' || ch == '+'))
{
self.next_char();
} else if last_idx == start_idx {
// 1e is not a valid floating point number
@ -483,9 +485,9 @@ impl<'a> Iterator for Lexer<'a> {
impl<'a> fmt::Display for Token<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Token::Name(name) => write!(f, "{}", name),
Token::Name(name) => write!(f, "{name}"),
Token::Scalar(ScalarToken::Int(s)) | Token::Scalar(ScalarToken::Float(s)) => {
write!(f, "{}", s)
write!(f, "{s}")
}
Token::Scalar(ScalarToken::String(s)) => {
write!(f, "\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\""))
@ -527,15 +529,15 @@ fn is_number_start(c: char) -> bool {
impl fmt::Display for LexerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
LexerError::UnknownCharacter(c) => write!(f, "Unknown character \"{}\"", c),
LexerError::UnknownCharacter(c) => write!(f, "Unknown character \"{c}\""),
LexerError::UnterminatedString => write!(f, "Unterminated string literal"),
LexerError::UnknownCharacterInString(c) => {
write!(f, "Unknown character \"{}\" in string literal", c)
write!(f, "Unknown character \"{c}\" in string literal")
}
LexerError::UnknownEscapeSequence(ref s) => {
write!(f, "Unknown escape sequence \"{}\" in string", s)
write!(f, "Unknown escape sequence \"{s}\" in string")
}
LexerError::UnexpectedCharacter(c) => write!(f, "Unexpected character \"{}\"", c),
LexerError::UnexpectedCharacter(c) => write!(f, "Unexpected character \"{c}\""),
LexerError::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
LexerError::InvalidNumber => write!(f, "Invalid number literal"),
}

92
juniper/src/parser/parser.rs
View file

@ -1,12 +1,16 @@
use std::{fmt, result::Result};
use std::{error::Error, fmt, result::Result};
use smartstring::alias::String;
use crate::parser::{Lexer, LexerError, Spanning, Token};
/// Error while parsing a GraphQL query
#[derive(Debug, PartialEq)]
pub enum ParseError<'a> {
pub enum ParseError {
/// An unexpected token occurred in the source
UnexpectedToken(Token<'a>),
// TODO: Previously was `Token<'a>`.
// Revisit on `graphql-parser` integration.
UnexpectedToken(String),
/// The input source abruptly ended
UnexpectedEndOfFile,
@ -18,14 +22,51 @@ pub enum ParseError<'a> {
ExpectedScalarError(&'static str),
}
#[doc(hidden)]
pub type ParseResult<'a, T> = Result<Spanning<T>, Spanning<ParseError<'a>>>;
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnexpectedToken(token) => write!(f, "Unexpected \"{token}\""),
Self::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
Self::LexerError(e) => e.fmt(f),
Self::ExpectedScalarError(e) => e.fmt(f),
}
}
}
impl Error for ParseError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::LexerError(e) => Some(e),
Self::ExpectedScalarError(_) | Self::UnexpectedToken(_) | Self::UnexpectedEndOfFile => {
None
}
}
}
}
impl ParseError {
/// Creates a [`ParseError::UnexpectedToken`] out of the provided [`Token`].
#[must_use]
pub fn unexpected_token(token: Token<'_>) -> Self {
use std::fmt::Write as _;
let mut s = String::new();
// PANIC: Unwrapping is OK here, as it may panic only on allocation
// error.
write!(s, "{token}").unwrap();
Self::UnexpectedToken(s)
}
}
#[doc(hidden)]
pub type UnlocatedParseResult<'a, T> = Result<T, Spanning<ParseError<'a>>>;
pub type ParseResult<T> = Result<Spanning<T>, Spanning<ParseError>>;
#[doc(hidden)]
pub type OptionParseResult<'a, T> = Result<Option<Spanning<T>>, Spanning<ParseError<'a>>>;
pub type UnlocatedParseResult<T> = Result<T, Spanning<ParseError>>;
#[doc(hidden)]
pub type OptionParseResult<T> = Result<Option<Spanning<T>>, Spanning<ParseError>>;
#[doc(hidden)]
#[derive(Debug)]
@ -54,7 +95,7 @@ impl<'a> Parser<'a> {
}
#[doc(hidden)]
pub fn next_token(&mut self) -> ParseResult<'a, Token<'a>> {
pub fn next_token(&mut self) -> ParseResult<Token<'a>> {
if self.tokens.len() == 1 {
Err(Spanning::start_end(
&self.peek().start,
@ -67,9 +108,9 @@ impl<'a> Parser<'a> {
}
#[doc(hidden)]
pub fn expect(&mut self, expected: &Token) -> ParseResult<'a, Token<'a>> {
pub fn expect(&mut self, expected: &Token) -> ParseResult<Token<'a>> {
if &self.peek().item != expected {
Err(self.next_token()?.map(ParseError::UnexpectedToken))
Err(self.next_token()?.map(ParseError::unexpected_token))
} else {
self.next_token()
}
@ -79,7 +120,7 @@ impl<'a> Parser<'a> {
pub fn skip(
&mut self,
expected: &Token,
) -> Result<Option<Spanning<Token<'a>>>, Spanning<ParseError<'a>>> {
) -> Result<Option<Spanning<Token<'a>>>, Spanning<ParseError>> {
if &self.peek().item == expected {
Ok(Some(self.next_token()?))
} else if self.peek().item == Token::EndOfFile {
@ -98,10 +139,10 @@ impl<'a> Parser<'a> {
opening: &Token,
parser: F,
closing: &Token,
) -> ParseResult<'a, Vec<Spanning<T>>>
) -> ParseResult<Vec<Spanning<T>>>
where
T: fmt::Debug,
F: Fn(&mut Parser<'a>) -> ParseResult<'a, T>,
F: Fn(&mut Parser<'a>) -> ParseResult<T>,
{
let Spanning {
start: start_pos, ..
@ -123,10 +164,10 @@ impl<'a> Parser<'a> {
opening: &Token,
parser: F,
closing: &Token,
) -> ParseResult<'a, Vec<Spanning<T>>>
) -> ParseResult<Vec<Spanning<T>>>
where
T: fmt::Debug,
F: Fn(&mut Parser<'a>) -> ParseResult<'a, T>,
F: Fn(&mut Parser<'a>) -> ParseResult<T>,
{
let Spanning {
start: start_pos, ..
@ -148,10 +189,10 @@ impl<'a> Parser<'a> {
opening: &Token,
parser: F,
closing: &Token,
) -> ParseResult<'a, Vec<T>>
) -> ParseResult<Vec<T>>
where
T: fmt::Debug,
F: Fn(&mut Parser<'a>) -> UnlocatedParseResult<'a, T>,
F: Fn(&mut Parser<'a>) -> UnlocatedParseResult<T>,
{
let Spanning {
start: start_pos, ..
@ -168,7 +209,7 @@ impl<'a> Parser<'a> {
}
#[doc(hidden)]
pub fn expect_name(&mut self) -> ParseResult<'a, &'a str> {
pub fn expect_name(&mut self) -> ParseResult<&'a str> {
match *self.peek() {
Spanning {
item: Token::Name(_),
@ -188,20 +229,7 @@ impl<'a> Parser<'a> {
&self.peek().end,
ParseError::UnexpectedEndOfFile,
)),
_ => Err(self.next_token()?.map(ParseError::UnexpectedToken)),
_ => Err(self.next_token()?.map(ParseError::unexpected_token)),
}
}
}
impl<'a> fmt::Display for ParseError<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ParseError::UnexpectedToken(ref token) => write!(f, "Unexpected \"{}\"", token),
ParseError::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
ParseError::LexerError(ref err) => err.fmt(f),
ParseError::ExpectedScalarError(err) => err.fmt(f),
}
}
}
impl<'a> std::error::Error for ParseError<'a> {}

13
juniper/src/parser/tests/document.rs
View file

@ -16,18 +16,15 @@ where
s,
&SchemaType::new::<QueryRoot, MutationRoot, SubscriptionRoot>(&(), &(), &()),
)
.expect(&format!("Parse error on input {:#?}", s))
.expect(&format!("Parse error on input {s:#?}"))
}
fn parse_document_error<'a, S>(s: &'a str) -> Spanning<ParseError<'a>>
where
S: ScalarValue,
{
fn parse_document_error<S: ScalarValue>(s: &str) -> Spanning<ParseError> {
match parse_document_source::<S>(
s,
&SchemaType::new::<QueryRoot, MutationRoot, SubscriptionRoot>(&(), &(), &()),
) {
Ok(doc) => panic!("*No* parse error on input {:#?} =>\n{:#?}", s, doc),
Ok(doc) => panic!("*No* parse error on input {s:#?} =>\n{doc:#?}"),
Err(err) => err,
}
}
@ -136,7 +133,7 @@ fn errors() {
Spanning::start_end(
&SourcePosition::new(36, 1, 19),
&SourcePosition::new(40, 1, 23),
ParseError::UnexpectedToken(Token::Name("Type"))
ParseError::UnexpectedToken("Type".into())
)
);
@ -145,7 +142,7 @@ fn errors() {
Spanning::start_end(
&SourcePosition::new(8, 0, 8),
&SourcePosition::new(9, 0, 9),
ParseError::UnexpectedToken(Token::CurlyClose)
ParseError::unexpected_token(Token::CurlyClose)
)
);
}

101
juniper/src/parser/tests/lexer.rs
View file

@ -13,8 +13,8 @@ fn tokenize_to_vec<'a>(s: &'a str) -> Vec<Spanning<Token<'a>>> {
break;
}
}
Some(Err(e)) => panic!("Error in input stream: {:#?} for {:#?}", e, s),
None => panic!("EOF before EndOfFile token in {:#?}", s),
Some(Err(e)) => panic!("Error in input stream: {e:#?} for {s:#?}"),
None => panic!("EOF before EndOfFile token in {s:#?}"),
}
}
@ -37,13 +37,13 @@ fn tokenize_error(s: &str) -> Spanning<LexerError> {
match lexer.next() {
Some(Ok(t)) => {
if t.item == Token::EndOfFile {
panic!("Tokenizer did not return error for {:#?}", s);
panic!("Tokenizer did not return error for {s:#?}");
}
}
Some(Err(e)) => {
return e;
}
None => panic!("Tokenizer did not return error for {:#?}", s),
None => panic!("Tokenizer did not return error for {s:#?}"),
}
}
}
@ -196,7 +196,7 @@ fn strings() {
Spanning::start_end(
&SourcePosition::new(0, 0, 0),
&SourcePosition::new(34, 0, 34),
Token::Scalar(ScalarToken::String(r#"unicode \u1234\u5678\u90AB\uCDEF"#))
Token::Scalar(ScalarToken::String(r#"unicode \u1234\u5678\u90AB\uCDEF"#)),
)
);
}
@ -207,7 +207,7 @@ fn string_errors() {
tokenize_error("\""),
Spanning::zero_width(
&SourcePosition::new(1, 0, 1),
LexerError::UnterminatedString
LexerError::UnterminatedString,
)
);
@ -215,7 +215,7 @@ fn string_errors() {
tokenize_error("\"no end quote"),
Spanning::zero_width(
&SourcePosition::new(13, 0, 13),
LexerError::UnterminatedString
LexerError::UnterminatedString,
)
);
@ -223,7 +223,7 @@ fn string_errors() {
tokenize_error("\"contains unescaped \u{0007} control char\""),
Spanning::zero_width(
&SourcePosition::new(20, 0, 20),
LexerError::UnknownCharacterInString('\u{0007}')
LexerError::UnknownCharacterInString('\u{0007}'),
)
);
@ -231,7 +231,7 @@ fn string_errors() {
tokenize_error("\"null-byte is not \u{0000} end of file\""),
Spanning::zero_width(
&SourcePosition::new(18, 0, 18),
LexerError::UnknownCharacterInString('\u{0000}')
LexerError::UnknownCharacterInString('\u{0000}'),
)
);
@ -239,7 +239,7 @@ fn string_errors() {
tokenize_error("\"multi\nline\""),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnterminatedString
LexerError::UnterminatedString,
)
);
@ -247,7 +247,7 @@ fn string_errors() {
tokenize_error("\"multi\rline\""),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnterminatedString
LexerError::UnterminatedString,
)
);
@ -255,7 +255,7 @@ fn string_errors() {
tokenize_error(r#""bad \z esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\z".to_owned())
LexerError::UnknownEscapeSequence("\\z".into()),
)
);
@ -263,7 +263,7 @@ fn string_errors() {
tokenize_error(r#""bad \x esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\x".to_owned())
LexerError::UnknownEscapeSequence("\\x".into()),
)
);
@ -271,7 +271,7 @@ fn string_errors() {
tokenize_error(r#""bad \u1 esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\u1".to_owned())
LexerError::UnknownEscapeSequence("\\u1".into()),
)
);
@ -279,7 +279,7 @@ fn string_errors() {
tokenize_error(r#""bad \u0XX1 esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\u0XX1".to_owned())
LexerError::UnknownEscapeSequence("\\u0XX1".into()),
)
);
@ -287,7 +287,7 @@ fn string_errors() {
tokenize_error(r#""bad \uXXXX esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\uXXXX".to_owned())
LexerError::UnknownEscapeSequence("\\uXXXX".into()),
)
);
@ -295,7 +295,7 @@ fn string_errors() {
tokenize_error(r#""bad \uFXXX esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\uFXXX".to_owned())
LexerError::UnknownEscapeSequence("\\uFXXX".into()),
)
);
@ -303,7 +303,7 @@ fn string_errors() {
tokenize_error(r#""bad \uXXXF esc""#),
Spanning::zero_width(
&SourcePosition::new(6, 0, 6),
LexerError::UnknownEscapeSequence("\\uXXXF".to_owned())
LexerError::UnknownEscapeSequence("\\uXXXF".into()),
)
);
@ -349,9 +349,7 @@ fn numbers() {
Token::Scalar(ScalarToken::Float(actual)) => {
assert!(
expected == actual,
"[expected] {} != {} [actual]",
expected,
actual
"[expected] {expected} != {actual} [actual]",
);
}
_ => assert!(false),
@ -662,39 +660,32 @@ fn punctuation_error() {
#[test]
fn display() {
assert_eq!(format!("{}", Token::Name("identifier")), "identifier");
assert_eq!(format!("{}", Token::Scalar(ScalarToken::Int("123"))), "123");
assert_eq!(
format!("{}", Token::Scalar(ScalarToken::Float("4.5"))),
"4.5"
);
assert_eq!(
format!("{}", Token::Scalar(ScalarToken::String("some string"))),
"\"some string\""
);
assert_eq!(
format!(
"{}",
Token::Scalar(ScalarToken::String("string with \\ escape and \" quote"))
for (input, expected) in [
(Token::Name("identifier"), "identifier"),
(Token::Scalar(ScalarToken::Int("123")), "123"),
(Token::Scalar(ScalarToken::Float("4.5")), "4.5"),
(
Token::Scalar(ScalarToken::String("some string")),
"\"some string\"",
),
"\"string with \\\\ escape and \\\" quote\""
);
assert_eq!(format!("{}", Token::ExclamationMark), "!");
assert_eq!(format!("{}", Token::Dollar), "$");
assert_eq!(format!("{}", Token::ParenOpen), "(");
assert_eq!(format!("{}", Token::ParenClose), ")");
assert_eq!(format!("{}", Token::BracketOpen), "[");
assert_eq!(format!("{}", Token::BracketClose), "]");
assert_eq!(format!("{}", Token::CurlyOpen), "{");
assert_eq!(format!("{}", Token::CurlyClose), "}");
assert_eq!(format!("{}", Token::Ellipsis), "...");
assert_eq!(format!("{}", Token::Colon), ":");
assert_eq!(format!("{}", Token::Equals), "=");
assert_eq!(format!("{}", Token::At), "@");
assert_eq!(format!("{}", Token::Pipe), "|");
(
Token::Scalar(ScalarToken::String("string with \\ escape and \" quote")),
"\"string with \\\\ escape and \\\" quote\"",
),
(Token::ExclamationMark, "!"),
(Token::Dollar, "$"),
(Token::ParenOpen, "("),
(Token::ParenClose, ")"),
(Token::BracketOpen, "["),
(Token::BracketClose, "]"),
(Token::CurlyOpen, "{"),
(Token::CurlyClose, "}"),
(Token::Ellipsis, "..."),
(Token::Colon, ":"),
(Token::Equals, "="),
(Token::At, "@"),
(Token::Pipe, "|"),
] {
assert_eq!(input.to_string(), expected);
}
}

4
juniper/src/parser/tests/value.rs
View file

@ -65,11 +65,11 @@ where
S: ScalarValue,
{
let mut lexer = Lexer::new(s);
let mut parser = Parser::new(&mut lexer).expect(&format!("Lexer error on input {:#?}", s));
let mut parser = Parser::new(&mut lexer).expect(&format!("Lexer error on input {s:#?}"));
let schema = SchemaType::new::<Query, EmptyMutation<()>, EmptySubscription<()>>(&(), &(), &());
parse_value_literal(&mut parser, false, &schema, Some(meta))
.expect(&format!("Parse error on input {:#?}", s))
.expect(&format!("Parse error on input {s:#?}"))
}
#[test]

9
juniper/src/parser/utils.rs
View file

@ -81,7 +81,7 @@ impl<T> Spanning<T> {
}
}
/// Modify the contents of the spanned item
/// Modify the contents of the spanned item.
pub fn map<O, F: Fn(T) -> O>(self, f: F) -> Spanning<O> {
Spanning {
item: f(self.item),
@ -89,6 +89,13 @@ impl<T> Spanning<T> {
end: self.end,
}
}
/// Modifies the contents of the spanned item in case `f` returns [`Some`],
/// or returns [`None`] otherwise.
pub fn and_then<O, F: Fn(T) -> Option<O>>(self, f: F) -> Option<Spanning<O>> {
let (start, end) = (self.start, self.end);
f(self.item).map(|item| Spanning { item, start, end })
}
}
impl<T: fmt::Display> fmt::Display for Spanning<T> {

34
juniper/src/parser/value.rs
View file

@ -9,12 +9,12 @@ use crate::{
value::ScalarValue,
};
pub fn parse_value_literal<'a, 'b, S>(
parser: &mut Parser<'a>,
pub fn parse_value_literal<'b, S>(
parser: &mut Parser<'_>,
is_const: bool,
schema: &'b SchemaType<'b, S>,
tpe: Option<&MetaType<'b, S>>,
) -> ParseResult<'a, InputValue<S>>
) -> ParseResult<InputValue<S>>
where
S: ScalarValue,
{
@ -113,16 +113,16 @@ where
},
_,
) => Ok(parser.next_token()?.map(|_| InputValue::enum_value(name))),
_ => Err(parser.next_token()?.map(ParseError::UnexpectedToken)),
_ => Err(parser.next_token()?.map(ParseError::unexpected_token)),
}
}
fn parse_list_literal<'a, 'b, S>(
parser: &mut Parser<'a>,
fn parse_list_literal<'b, S>(
parser: &mut Parser<'_>,
is_const: bool,
schema: &'b SchemaType<'b, S>,
tpe: Option<&MetaType<'b, S>>,
) -> ParseResult<'a, InputValue<S>>
) -> ParseResult<InputValue<S>>
where
S: ScalarValue,
{
@ -135,12 +135,12 @@ where
.map(InputValue::parsed_list))
}
fn parse_object_literal<'a, 'b, S>(
parser: &mut Parser<'a>,
fn parse_object_literal<'b, S>(
parser: &mut Parser<'_>,
is_const: bool,
schema: &'b SchemaType<'b, S>,
object_tpe: Option<&InputObjectMeta<'b, S>>,
) -> ParseResult<'a, InputValue<S>>
) -> ParseResult<InputValue<S>>
where
S: ScalarValue,
{
@ -153,12 +153,12 @@ where
.map(|items| InputValue::parsed_object(items.into_iter().map(|s| s.item).collect())))
}
fn parse_object_field<'a, 'b, S>(
parser: &mut Parser<'a>,
fn parse_object_field<'b, S>(
parser: &mut Parser<'_>,
is_const: bool,
schema: &'b SchemaType<'b, S>,
object_meta: Option<&InputObjectMeta<'b, S>>,
) -> ParseResult<'a, (Spanning<String>, Spanning<InputValue<S>>)>
) -> ParseResult<(Spanning<String>, Spanning<InputValue<S>>)>
where
S: ScalarValue,
{
@ -179,7 +179,7 @@ where
))
}
fn parse_variable_literal<'a, S>(parser: &mut Parser<'a>) -> ParseResult<'a, InputValue<S>>
fn parse_variable_literal<S>(parser: &mut Parser<'_>) -> ParseResult<InputValue<S>>
where
S: ScalarValue,
{
@ -199,12 +199,12 @@ where
))
}
fn parse_scalar_literal_by_infered_type<'a, 'b, S>(
token: ScalarToken<'a>,
fn parse_scalar_literal_by_infered_type<'b, S>(
token: ScalarToken<'_>,
start: &SourcePosition,
end: &SourcePosition,
schema: &'b SchemaType<'b, S>,
) -> ParseResult<'a, InputValue<S>>
) -> ParseResult<InputValue<S>>
where
S: ScalarValue,
{

2
juniper/src/resolve/mod.rs
View file

@ -200,5 +200,5 @@ pub trait InputValueAsRef<ScalarValue, Behavior: ?Sized = behavior::Standard> {
}
pub trait ScalarToken<ScalarValue, Behavior: ?Sized = behavior::Standard> {
fn parse_scalar_token(token: parser::ScalarToken<'_>) -> Result<ScalarValue, ParseError<'_>>;
fn parse_scalar_token(token: parser::ScalarToken<'_>) -> Result<ScalarValue, ParseError>;
}

39
juniper/src/schema/meta.rs
View file

@ -72,7 +72,7 @@ impl<'a, S> Clone for ScalarMeta<'a, S> {
pub type InputValueParseFn<S> = for<'b> fn(&'b InputValue<S>) -> Result<(), FieldError<S>>;
/// Shortcut for a [`ScalarToken`] parsing function.
pub type ScalarTokenParseFn<S> = for<'b> fn(ScalarToken<'b>) -> Result<S, ParseError<'b>>;
pub type ScalarTokenParseFn<S> = for<'b> fn(ScalarToken<'b>) -> Result<S, ParseError>;
/// List type metadata
#[derive(Clone, Debug)]
@ -433,7 +433,7 @@ impl<'a, S> MetaType<'a, S> {
// "used exclusively by GraphQL’s introspection system"
{
name.starts_with("__") ||
// <https://facebook.github.io/graphql/draft/#sec-Scalars>
// https://spec.graphql.org/October2021#sec-Scalars
name == "Boolean" || name == "String" || name == "Int" || name == "Float" || name == "ID" ||
// Our custom empty markers
name == "_EmptyMutation" || name == "_EmptySubscription"
@ -543,7 +543,7 @@ impl<'a, S> ScalarMeta<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -613,7 +613,7 @@ impl<'a, S> ObjectMeta<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -624,7 +624,7 @@ impl<'a, S> ObjectMeta<'a, S> {
pub fn interfaces(mut self, interfaces: &[Type<'a>]) -> Self {
self.interface_names = interfaces
.iter()
.map(|t| t.innermost_name().to_owned())
.map(|t| t.innermost_name().into())
.collect();
self
}
@ -674,7 +674,7 @@ impl<'a, S> EnumMeta<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -704,7 +704,7 @@ impl<'a, S> InterfaceMeta<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -715,7 +715,7 @@ impl<'a, S> InterfaceMeta<'a, S> {
pub fn interfaces(mut self, interfaces: &[Type<'a>]) -> Self {
self.interface_names = interfaces
.iter()
.map(|t| t.innermost_name().to_owned())
.map(|t| t.innermost_name().into())
.collect();
self
}
@ -733,10 +733,7 @@ impl<'a> UnionMeta<'a> {
Self {
name,
description: None,
of_type_names: of_types
.iter()
.map(|t| t.innermost_name().to_owned())
.collect(),
of_type_names: of_types.iter().map(|t| t.innermost_name().into()).collect(),
}
}
@ -745,7 +742,7 @@ impl<'a> UnionMeta<'a> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -777,7 +774,7 @@ impl<'a, S> InputObjectMeta<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -793,7 +790,7 @@ impl<'a, S> Field<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -818,7 +815,7 @@ impl<'a, S> Field<'a, S> {
/// Overwrites any previously set deprecation reason.
#[must_use]
pub fn deprecated(mut self, reason: Option<&str>) -> Self {
self.deprecation_status = DeprecationStatus::Deprecated(reason.map(ToOwned::to_owned));
self.deprecation_status = DeprecationStatus::Deprecated(reason.map(Into::into));
self
}
}
@ -827,7 +824,7 @@ impl<'a, S> Argument<'a, S> {
/// Builds a new [`Argument`] of the given [`Type`] with the given `name`.
pub fn new(name: &str, arg_type: Type<'a>) -> Self {
Self {
name: name.to_owned(),
name: name.into(),
description: None,
arg_type,
default_value: None,
@ -839,7 +836,7 @@ impl<'a, S> Argument<'a, S> {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -857,7 +854,7 @@ impl EnumValue {
/// Constructs a new [`EnumValue`] with the provided `name`.
pub fn new(name: &str) -> Self {
Self {
name: name.to_owned(),
name: name.into(),
description: None,
deprecation_status: DeprecationStatus::Current,
}
@ -868,7 +865,7 @@ impl EnumValue {
/// Overwrites any previously set description.
#[must_use]
pub fn description(mut self, description: &str) -> Self {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
@ -877,7 +874,7 @@ impl EnumValue {
/// Overwrites any previously set deprecation reason.
#[must_use]
pub fn deprecated(mut self, reason: Option<&str>) -> Self {
self.deprecation_status = DeprecationStatus::Deprecated(reason.map(ToOwned::to_owned));
self.deprecation_status = DeprecationStatus::Deprecated(reason.map(Into::into));
self
}
}

39
juniper/src/schema/model.rs
View file

@ -167,8 +167,7 @@ where
/// [GraphQL Schema Language](https://graphql.org/learn/schema/#type-language)
/// format.
pub fn as_schema_language(&self) -> String {
let doc = self.as_parser_document();
format!("{}", doc)
self.as_parser_document().to_string()
}
#[cfg(feature = "graphql-parser")]
@ -210,17 +209,14 @@ impl<'a, S> SchemaType<'a, S> {
registry.get_type::<SchemaType<S>>(&());
directives.insert("skip".to_owned(), DirectiveType::new_skip(&mut registry));
directives.insert("skip".into(), DirectiveType::new_skip(&mut registry));
directives.insert("include".into(), DirectiveType::new_include(&mut registry));
directives.insert(
"include".to_owned(),
DirectiveType::new_include(&mut registry),
);
directives.insert(
"deprecated".to_owned(),
"deprecated".into(),
DirectiveType::new_deprecated(&mut registry),
);
directives.insert(
"specifiedBy".to_owned(),
"specifiedBy".into(),
DirectiveType::new_specified_by(&mut registry),
);
@ -243,7 +239,7 @@ impl<'a, S> SchemaType<'a, S> {
for meta_type in registry.types.values() {
if let MetaType::Placeholder(PlaceholderMeta { ref of_type }) = *meta_type {
panic!("Type {:?} is still a placeholder type", of_type);
panic!("Type {of_type:?} is still a placeholder type");
}
}
SchemaType {
@ -508,9 +504,9 @@ where
locations: &[DirectiveLocation],
arguments: &[Argument<'a, S>],
is_repeatable: bool,
) -> DirectiveType<'a, S> {
DirectiveType {
name: name.to_owned(),
) -> Self {
Self {
name: name.into(),
description: None,
locations: locations.to_vec(),
arguments: arguments.to_vec(),
@ -578,7 +574,7 @@ where
}
pub fn description(mut self, description: &str) -> DirectiveType<'a, S> {
self.description = Some(description.to_owned());
self.description = Some(description.into());
self
}
}
@ -605,8 +601,8 @@ impl<'a, S> fmt::Display for TypeType<'a, S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Concrete(t) => f.write_str(t.name().unwrap()),
Self::List(i, _) => write!(f, "[{}]", i),
Self::NonNull(i) => write!(f, "{}!", i),
Self::List(i, _) => write!(f, "[{i}]"),
Self::NonNull(i) => write!(f, "{i}!"),
}
}
}
@ -644,10 +640,7 @@ mod test {
"#,
)
.unwrap();
assert_eq!(
format!("{}", ast),
format!("{}", schema.as_parser_document()),
);
assert_eq!(ast.to_string(), schema.as_parser_document().to_string());
}
}
@ -691,10 +684,10 @@ mod test {
}
/// This is whatever's description.
fn whatever() -> String {
"foo".to_string()
"foo".into()
}
fn arr(stuff: Vec<Coordinate>) -> Option<&'static str> {
(!stuff.is_empty()).then(|| "stuff")
(!stuff.is_empty()).then_some("stuff")
}
fn fruit() -> Fruit {
Fruit::Apple
@ -754,7 +747,7 @@ mod test {
"#,
)
.unwrap();
assert_eq!(format!("{}", ast), schema.as_schema_language());
assert_eq!(ast.to_string(), schema.as_schema_language());
}
}
}

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

@ -211,13 +211,19 @@ impl<'a, S: ScalarValue + 'a> TypeType<'a, S> {
}
}
fn fields(&self, #[graphql(default)] include_deprecated: bool) -> Option<Vec<&Field<S>>> {
fn fields(
&self,
#[graphql(default = false)] include_deprecated: Option<bool>,
) -> Option<Vec<&Field<S>>> {
match self {
TypeType::Concrete(&MetaType::Interface(InterfaceMeta { ref fields, .. }))
| TypeType::Concrete(&MetaType::Object(ObjectMeta { ref fields, .. })) => Some(
fields
.iter()
.filter(|f| include_deprecated || !f.deprecation_status.is_deprecated())
.filter(|f| {
include_deprecated.unwrap_or_default()
|| !f.deprecation_status.is_deprecated()
})
.filter(|f| !f.name.starts_with("__"))
.collect(),
),
@ -282,16 +288,16 @@ impl<'a, S: ScalarValue + 'a> TypeType<'a, S> {
.iter()
.filter_map(|&ct| {
if let MetaType::Object(ObjectMeta {
ref name,
ref interface_names,
name,
interface_names,
..
}) = *ct
}) = ct
{
if interface_names.contains(&iface_name.to_string()) {
context.type_by_name(name)
} else {
None
}
interface_names
.iter()
.any(|name| name == iface_name)
.then(|| context.type_by_name(name))
.flatten()
} else {
None
}
@ -302,12 +308,18 @@ impl<'a, S: ScalarValue + 'a> TypeType<'a, S> {
}
}
fn enum_values(&self, #[graphql(default)] include_deprecated: bool) -> Option<Vec<&EnumValue>> {
fn enum_values(
&self,
#[graphql(default = false)] include_deprecated: Option<bool>,
) -> Option<Vec<&EnumValue>> {
match self {
TypeType::Concrete(&MetaType::Enum(EnumMeta { ref values, .. })) => Some(
values
.iter()
.filter(|f| include_deprecated || !f.deprecation_status.is_deprecated())
.filter(|f| {
include_deprecated.unwrap_or_default()
|| !f.deprecation_status.is_deprecated()
})
.collect(),
),
_ => None,

20
juniper/src/schema/translate/graphql_parser.rs
View file

@ -285,22 +285,18 @@ where
DeprecationStatus::Current => None,
DeprecationStatus::Deprecated(reason) => Some(ExternalDirective {
position: Pos::default(),
name: From::from("deprecated"),
arguments: if let Some(reason) = reason {
vec![(
From::from("reason"),
ExternalValue::String(reason.to_string()),
)]
} else {
vec![]
},
name: "deprecated".into(),
arguments: reason
.as_ref()
.map(|rsn| vec![(From::from("reason"), ExternalValue::String(rsn.into()))])
.unwrap_or_default(),
}),
}
}
// Right now the only directive supported is `@deprecated`. `@skip` and `@include`
// are dealt with elsewhere.
// <https://facebook.github.io/graphql/draft/#sec-Type-System.Directives>
// Right now the only directive supported is `@deprecated`.
// `@skip` and `@include` are dealt with elsewhere.
// https://spec.graphql.org/October2021#sec-Type-System.Directives.Built-in-Directives
fn generate_directives<'a, T>(status: &DeprecationStatus) -> Vec<ExternalDirective<'a, T>>
where
T: Text<'a>,

36
juniper/src/tests/fixtures/starwars/schema.rs vendored
View file

@ -93,12 +93,12 @@ impl Human {
home_planet: Option<&str>,
) -> Self {
Self {
id: id.to_owned(),
name: name.to_owned(),
friend_ids: friend_ids.iter().copied().map(ToOwned::to_owned).collect(),
id: id.into(),
name: name.into(),
friend_ids: friend_ids.iter().copied().map(Into::into).collect(),
appears_in: appears_in.to_vec(),
secret_backstory: secret_backstory.map(ToOwned::to_owned),
home_planet: home_planet.map(|p| p.to_owned()),
secret_backstory: secret_backstory.map(Into::into),
home_planet: home_planet.map(Into::into),
}
}
}
@ -153,12 +153,12 @@ impl Droid {
primary_function: Option<&str>,
) -> Self {
Self {
id: id.to_owned(),
name: name.to_owned(),
friend_ids: friend_ids.iter().copied().map(ToOwned::to_owned).collect(),
id: id.into(),
name: name.into(),
friend_ids: friend_ids.iter().copied().map(Into::into).collect(),
appears_in: appears_in.to_vec(),
secret_backstory: secret_backstory.map(ToOwned::to_owned),
primary_function: primary_function.map(ToOwned::to_owned),
secret_backstory: secret_backstory.map(Into::into),
primary_function: primary_function.map(Into::into),
}
}
}
@ -192,7 +192,7 @@ impl Droid {
}
}
#[derive(Default, Clone)]
#[derive(Clone, Default)]
pub struct Database {
humans: HashMap<String, Human>,
droids: HashMap<String, Droid>,
@ -206,7 +206,7 @@ impl Database {
let mut droids = HashMap::new();
humans.insert(
"1000".to_owned(),
"1000".into(),
Human::new(
"1000",
"Luke Skywalker",
@ -218,7 +218,7 @@ impl Database {
);
humans.insert(
"1001".to_owned(),
"1001".into(),
Human::new(
"1001",
"Darth Vader",
@ -230,7 +230,7 @@ impl Database {
);
humans.insert(
"1002".to_owned(),
"1002".into(),
Human::new(
"1002",
"Han Solo",
@ -242,7 +242,7 @@ impl Database {
);
humans.insert(
"1003".to_owned(),
"1003".into(),
Human::new(
"1003",
"Leia Organa",
@ -254,7 +254,7 @@ impl Database {
);
humans.insert(
"1004".to_owned(),
"1004".into(),
Human::new(
"1004",
"Wilhuff Tarkin",
@ -266,7 +266,7 @@ impl Database {
);
droids.insert(
"2000".to_owned(),
"2000".into(),
Droid::new(
"2000",
"C-3PO",
@ -278,7 +278,7 @@ impl Database {
);
droids.insert(
"2001".to_owned(),
"2001".into(),
Droid::new(
"2001",
"R2-D2",

51
juniper/src/tests/subscriptions.rs
View file

@ -1,4 +1,4 @@
use std::{iter, iter::FromIterator as _, pin::Pin};
use std::{iter, pin::Pin};
use futures::{stream, StreamExt as _};
@ -48,9 +48,9 @@ impl MySubscription {
async fn async_human() -> HumanStream {
Box::pin(stream::once(async {
Human {
id: "stream id".to_string(),
name: "stream name".to_string(),
home_planet: "stream home planet".to_string(),
id: "stream id".into(),
name: "stream name".into(),
home_planet: "stream home planet".into(),
}
}))
}
@ -78,7 +78,7 @@ impl MySubscription {
Human {
id,
name,
home_planet: "default home planet".to_string(),
home_planet: "default home planet".into(),
}
}))
}
@ -154,10 +154,10 @@ fn returns_requested_object() {
id
name
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(
@ -182,10 +182,9 @@ fn returns_error() {
id
name
}
}"#
.to_string();
}"#;
let response = create_and_execute(query);
let response = create_and_execute(query.into());
assert!(response.is_err());
@ -206,10 +205,10 @@ fn can_access_context() {
humanWithContext {
id
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(iter::from_fn(
@ -234,10 +233,10 @@ fn resolves_typed_inline_fragments() {
id
}
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(iter::from_fn(
@ -262,10 +261,10 @@ fn resolves_nontyped_inline_fragments() {
id
}
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(iter::from_fn(
@ -289,10 +288,10 @@ fn can_access_arguments() {
id
name
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(iter::from_fn(
@ -317,10 +316,10 @@ fn type_alias() {
id
name
}
}"#
.to_string();
}"#;
let (names, collected_values) = create_and_execute(query).expect("Got error from stream");
let (names, collected_values) =
create_and_execute(query.into()).expect("Got error from stream");
let mut iterator_count = 0;
let expected_values = vec![vec![Ok(Value::Object(Object::from_iter(iter::from_fn(

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

@ -75,15 +75,15 @@ fn test_node() {
baz
}"#;
let node_info = NodeTypeInfo {
name: "MyNode".to_string(),
attribute_names: vec!["foo".to_string(), "bar".to_string(), "baz".to_string()],
name: "MyNode".into(),
attribute_names: vec!["foo".into(), "bar".into(), "baz".into()],
};
let mut node = Node {
attributes: IndexMap::new(),
};
node.attributes.insert("foo".to_string(), "1".to_string());
node.attributes.insert("bar".to_string(), "2".to_string());
node.attributes.insert("baz".to_string(), "3".to_string());
node.attributes.insert("foo".into(), "1".into());
node.attributes.insert("bar".into(), "2".into());
node.attributes.insert("baz".into(), "3".into());
let schema: RootNode<_, _, _> = RootNode::new_with_info(
node,
EmptyMutation::new(),

2
juniper/src/types/arc.rs
View file

@ -200,7 +200,7 @@ where
T: resolve::ScalarToken<SV, BH> + ?Sized,
BH: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

11
juniper/src/types/array.rs
View file

@ -289,12 +289,11 @@ where
fn into_field_error(self) -> FieldError<SV> {
const ERROR_PREFIX: &str = "Failed to convert into exact-size array";
match self {
Self::IsNull => format!("{}: Value cannot be `null`", ERROR_PREFIX).into(),
Self::WrongCount { actual, expected } => format!(
"{}: wrong elements count: {} instead of {}",
ERROR_PREFIX, actual, expected,
)
.into(),
Self::IsNull => format!("{ERROR_PREFIX}: Value cannot be `null`").into(),
Self::WrongCount { actual, expected } => {
format!("{ERROR_PREFIX}: wrong elements count: {actual} instead of {expected}",)
.into()
}
Self::Item(s) => s.into_field_error(),
}
}

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

@ -30,7 +30,7 @@ where
///
/// The default implementation panics.
///
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve_field_async<'a>(
&'a self,
_info: &'a Self::TypeInfo,
@ -54,9 +54,9 @@ where
///
/// The default implementation panics.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [2]: https://spec.graphql.org/June2018/#sec-Unions
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Interfaces
/// [2]: https://spec.graphql.org/October2021#sec-Unions
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve_into_type_async<'a>(
&'a self,
info: &'a Self::TypeInfo,
@ -91,8 +91,8 @@ where
///
/// The default implementation panics, if `selection_set` is [`None`].
///
/// [0]: https://spec.graphql.org/June2018/#sec-Errors-and-Non-Nullability
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [0]: https://spec.graphql.org/October2021#sec-Handling-Field-Errors
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve_async<'a>(
&'a self,
info: &'a Self::TypeInfo,
@ -226,7 +226,7 @@ where
panic!(
"Field {} not found on type {:?}",
f.name.item,
meta_type.name()
meta_type.name(),
)
});
@ -242,7 +242,9 @@ where
f.arguments.as_ref().map(|m| {
m.item
.iter()
.map(|&(ref k, ref v)| (k.item, v.item.clone().into_const(exec_vars)))
.filter_map(|&(ref k, ref v)| {
v.item.clone().into_const(exec_vars).map(|v| (k.item, v))
})
.collect()
}),
&meta_field.arguments,

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

@ -49,7 +49,6 @@ pub enum TypeKind {
/// ## Input objects
///
/// Represents complex values provided in queries _into_ the system.
#[graphql(name = "INPUT_OBJECT")]
InputObject,
/// ## List types
@ -63,7 +62,6 @@ pub enum TypeKind {
///
/// In GraphQL, nullable types are the default. By putting a `!` after a\
/// type, it becomes non-nullable.
#[graphql(name = "NON_NULL")]
NonNull,
}
@ -89,7 +87,7 @@ impl<'a, S> Arguments<'a, S> {
if let (Some(args), Some(meta_args)) = (&mut args, meta_args) {
for arg in meta_args {
let arg_name = arg.name.as_str();
if args.get(arg_name).map_or(true, InputValue::is_null) {
if args.get(arg_name).is_none() {
if let Some(val) = arg.default_value.as_ref() {
args.insert(arg_name, val.clone());
}
@ -150,14 +148,14 @@ impl<'a, S> Arguments<'a, S> {
/// This trait is intended to be used in a conjunction with a [`GraphQLType`] trait. See the example
/// in the documentation of a [`GraphQLType`] trait.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [2]: https://spec.graphql.org/June2018/#sec-Unions
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [4]: https://spec.graphql.org/June2018/#sec-Scalars
/// [5]: https://spec.graphql.org/June2018/#sec-Enums
/// [6]: https://spec.graphql.org/June2018/#sec-Type-System.List
/// [7]: https://spec.graphql.org/June2018/#sec-Type-System.Non-Null
/// [8]: https://spec.graphql.org/June2018/#sec-Input-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Interfaces
/// [2]: https://spec.graphql.org/October2021#sec-Unions
/// [3]: https://spec.graphql.org/October2021#sec-Objects
/// [4]: https://spec.graphql.org/October2021#sec-Scalars
/// [5]: https://spec.graphql.org/October2021#sec-Enums
/// [6]: https://spec.graphql.org/October2021#sec-List
/// [7]: https://spec.graphql.org/October2021#sec-Non-Null
/// [8]: https://spec.graphql.org/October2021#sec-Input-Objects
/// [11]: https://doc.rust-lang.org/reference/items/traits.html#object-safety
/// [12]: https://doc.rust-lang.org/reference/types/trait-object.html
pub trait GraphQLValue<S = DefaultScalarValue>
@ -196,7 +194,7 @@ where
///
/// The default implementation panics.
///
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve_field(
&self,
_info: &Self::TypeInfo,
@ -217,9 +215,9 @@ where
///
/// The default implementation panics.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [2]: https://spec.graphql.org/June2018/#sec-Unions
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Interfaces
/// [2]: https://spec.graphql.org/October2021#sec-Unions
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve_into_type(
&self,
info: &Self::TypeInfo,
@ -243,9 +241,9 @@ where
///
/// The default implementation panics.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [2]: https://spec.graphql.org/June2018/#sec-Unions
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Interfaces
/// [2]: https://spec.graphql.org/October2021#sec-Unions
/// [3]: https://spec.graphql.org/October2021#sec-Objects
#[allow(unused_variables)]
fn concrete_type_name(&self, context: &Self::Context, info: &Self::TypeInfo) -> String {
panic!(
@ -271,8 +269,8 @@ where
///
/// The default implementation panics, if `selection_set` is [`None`].
///
/// [0]: https://spec.graphql.org/June2018/#sec-Errors-and-Non-Nullability
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [0]: https://spec.graphql.org/October2021#sec-Errors-and-Non-Nullability
/// [3]: https://spec.graphql.org/October2021#sec-Objects
fn resolve(
&self,
info: &Self::TypeInfo,
@ -379,13 +377,13 @@ where
/// // schema in `meta()` above, or a validation failed because of a this library bug.
/// //
/// // In either of those two cases, the only reasonable way out is to panic the thread.
/// _ => panic!("Field {} not found on type User", field_name),
/// _ => panic!("Field {field_name} not found on type User"),
/// }
/// }
/// }
/// ```
///
/// [3]: https://spec.graphql.org/June2018/#sec-Objects
/// [3]: https://spec.graphql.org/October2021#sec-Objects
pub trait GraphQLType<S = DefaultScalarValue>: GraphQLValue<S>
where
S: ScalarValue,
@ -454,7 +452,7 @@ where
panic!(
"Field {} not found on type {:?}",
f.name.item,
meta_type.name()
meta_type.name(),
)
});
@ -474,8 +472,8 @@ where
f.arguments.as_ref().map(|m| {
m.item
.iter()
.map(|&(ref k, ref v)| {
(k.item, v.item.clone().into_const(exec_vars))
.filter_map(|&(ref k, ref v)| {
v.item.clone().into_const(exec_vars).map(|v| (k.item, v))
})
.collect()
}),
@ -608,7 +606,7 @@ where
.arguments
.iter()
.flat_map(|m| m.item.get("if"))
.flat_map(|v| v.item.clone().into_const(vars).convert())
.filter_map(|v| v.item.clone().into_const(vars)?.convert().ok())
.next()
.unwrap();

2
juniper/src/types/box.rs
View file

@ -198,7 +198,7 @@ where
T: resolve::ScalarToken<SV, BH> + ?Sized,
BH: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

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

@ -522,12 +522,11 @@ where
fn into_field_error(self) -> FieldError<S> {
const ERROR_PREFIX: &str = "Failed to convert into exact-size array";
match self {
Self::Null => format!("{}: Value cannot be `null`", ERROR_PREFIX).into(),
Self::WrongCount { actual, expected } => format!(
"{}: wrong elements count: {} instead of {}",
ERROR_PREFIX, actual, expected
)
.into(),
Self::Null => format!("{ERROR_PREFIX}: Value cannot be `null`").into(),
Self::WrongCount { actual, expected } => {
format!("{ERROR_PREFIX}: wrong elements count: {actual} instead of {expected}",)
.into()
}
Self::Item(s) => s.into_field_error(),
}
}

2
juniper/src/types/cow.rs
View file

@ -215,7 +215,7 @@ where
BH: ?Sized,
Self: Deref<Target = T>,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

56
juniper/src/types/marker.rs
View file

@ -17,23 +17,23 @@ use crate::{GraphQLType, ScalarValue};
/// [GraphQL objects][1]. Other types ([scalars][2], [enums][3], [interfaces][4], [input objects][5]
/// and [unions][6]) are not allowed.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Objects
/// [2]: https://spec.graphql.org/June2018/#sec-Scalars
/// [3]: https://spec.graphql.org/June2018/#sec-Enums
/// [4]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [5]: https://spec.graphql.org/June2018/#sec-Input-Objects
/// [6]: https://spec.graphql.org/June2018/#sec-Unions
/// [1]: https://spec.graphql.org/October2021#sec-Objects
/// [2]: https://spec.graphql.org/October2021#sec-Scalars
/// [3]: https://spec.graphql.org/October2021#sec-Enums
/// [4]: https://spec.graphql.org/October2021#sec-Interfaces
/// [5]: https://spec.graphql.org/October2021#sec-Input-Objects
/// [6]: https://spec.graphql.org/October2021#sec-Unions
pub trait GraphQLObject<S: ScalarValue>: GraphQLType<S> {
/// An arbitrary function without meaning.
///
/// May contain compile timed check logic which ensures that types are used correctly according
/// to the [GraphQL specification][1].
///
/// [1]: https://spec.graphql.org/June2018/
/// [1]: https://spec.graphql.org/October2021
fn mark() {}
}
impl<'a, S, T> GraphQLObject<S> for &T
impl<S, T> GraphQLObject<S> for &T
where
T: GraphQLObject<S> + ?Sized,
S: ScalarValue,
@ -74,23 +74,23 @@ where
/// [GraphQL interfaces][1]. Other types ([scalars][2], [enums][3], [objects][4], [input objects][5]
/// and [unions][6]) are not allowed.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [2]: https://spec.graphql.org/June2018/#sec-Scalars
/// [3]: https://spec.graphql.org/June2018/#sec-Enums
/// [4]: https://spec.graphql.org/June2018/#sec-Objects
/// [5]: https://spec.graphql.org/June2018/#sec-Input-Objects
/// [6]: https://spec.graphql.org/June2018/#sec-Unions
/// [1]: https://spec.graphql.org/October2021#sec-Interfaces
/// [2]: https://spec.graphql.org/October2021#sec-Scalars
/// [3]: https://spec.graphql.org/October2021#sec-Enums
/// [4]: https://spec.graphql.org/October2021#sec-Objects
/// [5]: https://spec.graphql.org/October2021#sec-Input-Objects
/// [6]: https://spec.graphql.org/October2021#sec-Unions
pub trait GraphQLInterface<S: ScalarValue>: GraphQLType<S> {
/// An arbitrary function without meaning.
///
/// May contain compile timed check logic which ensures that types are used correctly according
/// to the [GraphQL specification][1].
///
/// [1]: https://spec.graphql.org/June2018/
/// [1]: https://spec.graphql.org/October2021
fn mark() {}
}
impl<'a, S, T> GraphQLInterface<S> for &T
impl<S, T> GraphQLInterface<S> for &T
where
T: GraphQLInterface<S> + ?Sized,
S: ScalarValue,
@ -131,23 +131,23 @@ where
/// [GraphQL unions][1]. Other types ([scalars][2], [enums][3], [objects][4], [input objects][5] and
/// [interfaces][6]) are not allowed.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Unions
/// [2]: https://spec.graphql.org/June2018/#sec-Scalars
/// [3]: https://spec.graphql.org/June2018/#sec-Enums
/// [4]: https://spec.graphql.org/June2018/#sec-Objects
/// [5]: https://spec.graphql.org/June2018/#sec-Input-Objects
/// [6]: https://spec.graphql.org/June2018/#sec-Interfaces
/// [1]: https://spec.graphql.org/October2021#sec-Unions
/// [2]: https://spec.graphql.org/October2021#sec-Scalars
/// [3]: https://spec.graphql.org/October2021#sec-Enums
/// [4]: https://spec.graphql.org/October2021#sec-Objects
/// [5]: https://spec.graphql.org/October2021#sec-Input-Objects
/// [6]: https://spec.graphql.org/October2021#sec-Interfaces
pub trait GraphQLUnion<S: ScalarValue>: GraphQLType<S> {
/// An arbitrary function without meaning.
///
/// May contain compile timed check logic which ensures that types are used correctly according
/// to the [GraphQL specification][1].
///
/// [1]: https://spec.graphql.org/June2018/
/// [1]: https://spec.graphql.org/October2021
fn mark() {}
}
impl<'a, S, T> GraphQLUnion<S> for &T
impl<S, T> GraphQLUnion<S> for &T
where
T: GraphQLUnion<S> + ?Sized,
S: ScalarValue,
@ -194,7 +194,7 @@ pub trait IsOutputType<S: ScalarValue>: GraphQLType<S> {
fn mark() {}
}
impl<'a, S, T> IsOutputType<S> for &T
impl<S, T> IsOutputType<S> for &T
where
T: IsOutputType<S> + ?Sized,
S: ScalarValue,
@ -271,7 +271,7 @@ where
}
}
impl<'a, S> IsOutputType<S> for str where S: ScalarValue {}
impl<S> IsOutputType<S> for str where S: ScalarValue {}
/// Marker trait for types which can be used as input types.
///
@ -287,7 +287,7 @@ pub trait IsInputType<S: ScalarValue>: GraphQLType<S> {
fn mark() {}
}
impl<'a, S, T> IsInputType<S> for &T
impl<S, T> IsInputType<S> for &T
where
T: IsInputType<S> + ?Sized,
S: ScalarValue,
@ -364,4 +364,4 @@ where
}
}
impl<'a, S> IsInputType<S> for str where S: ScalarValue {}
impl<S> IsInputType<S> for str where S: ScalarValue {}

5
juniper/src/types/name.rs
View file

@ -50,11 +50,10 @@ impl FromStr for Name {
type Err = NameParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if Name::is_valid(s) {
Ok(Name(s.to_string()))
Ok(Name(s.into()))
} else {
Err(NameParseError(format!(
"Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but \"{}\" does not",
s
"Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but \"{s}\" does not",
)))
}
}

2
juniper/src/types/nullable.rs
View file

@ -51,6 +51,8 @@ pub enum Nullable<T> {
Some(T),
}
// Implemented manually to omit redundant `T: Default` trait bound, imposed by
// `#[derive(Default)]`.
impl<T> Default for Nullable<T> {
fn default() -> Self {
Self::ImplicitNull

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

@ -265,7 +265,7 @@ where
}
}
impl<'e, S, T> GraphQLValueAsync<S> for Arc<T>
impl<S, T> GraphQLValueAsync<S> for Arc<T>
where
T: GraphQLValueAsync<S> + Send + ?Sized,
T::TypeInfo: Sync,

2
juniper/src/types/rc.rs
View file

@ -200,7 +200,7 @@ where
T: resolve::ScalarToken<SV, BH> + ?Sized,
BH: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

2
juniper/src/types/ref.rs
View file

@ -202,7 +202,7 @@ where
T: resolve::ScalarToken<SV, BH> + ?Sized,
BH: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

2
juniper/src/types/ref_mut.rs
View file

@ -166,7 +166,7 @@ where
T: resolve::ScalarToken<SV, BH> + ?Sized,
BH: ?Sized,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
T::parse_scalar_token(token)
}
}

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

@ -37,7 +37,7 @@ impl ID {
.map(str::to_owned)
.or_else(|| v.as_int_value().as_ref().map(ToString::to_string))
.map(Self)
.ok_or_else(|| format!("Expected `String` or `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `String` or `Int`, found: {v}"))
}
}
@ -81,10 +81,10 @@ mod impl_string_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<String, String> {
v.as_string_value()
.map(str::to_owned)
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
}
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S> {
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<S> {
if let ScalarToken::String(value) = value {
let mut ret = String::with_capacity(value.len());
let mut char_iter = value.chars();
@ -120,7 +120,7 @@ mod impl_string_scalar {
}
Some(s) => {
return Err(ParseError::LexerError(LexerError::UnknownEscapeSequence(
format!("\\{}", s),
format!("\\{s}"),
)))
}
None => return Err(ParseError::LexerError(LexerError::UnterminatedString)),
@ -132,12 +132,12 @@ mod impl_string_scalar {
}
Ok(ret.into())
} else {
Err(ParseError::UnexpectedToken(Token::Scalar(value)))
Err(ParseError::unexpected_token(Token::Scalar(value)))
}
}
}
fn parse_unicode_codepoint<'a, I>(char_iter: &mut I) -> Result<char, ParseError<'a>>
fn parse_unicode_codepoint<I>(char_iter: &mut I) -> Result<char, ParseError>
where
I: Iterator<Item = char>,
{
@ -149,19 +149,16 @@ where
.and_then(|c1| {
char_iter
.next()
.map(|c2| format!("{}{}", c1, c2))
.map(|c2| format!("{c1}{c2}"))
.ok_or_else(|| {
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!("\\u{}", c1)))
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!("\\u{c1}")))
})
})
.and_then(|mut s| {
char_iter
.next()
.ok_or_else(|| {
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!(
"\\u{}",
s.clone()
)))
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!("\\u{s}")))
})
.map(|c2| {
s.push(c2);
@ -172,10 +169,7 @@ where
char_iter
.next()
.ok_or_else(|| {
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!(
"\\u{}",
s.clone()
)))
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!("\\u{s}")))
})
.map(|c2| {
s.push(c2);
@ -184,14 +178,12 @@ where
})?;
let code_point = u32::from_str_radix(&escaped_code_point, 16).map_err(|_| {
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!(
"\\u{}",
escaped_code_point
"\\u{escaped_code_point}",
)))
})?;
char::from_u32(code_point).ok_or_else(|| {
ParseError::LexerError(LexerError::UnknownEscapeSequence(format!(
"\\u{}",
escaped_code_point
"\\u{escaped_code_point}",
)))
})
}
@ -282,12 +274,12 @@ mod impl_boolean_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Boolean, String> {
v.as_scalar_value()
.and_then(ScalarValue::as_bool)
.ok_or_else(|| format!("Expected `Boolean`, found: {}", v))
.ok_or_else(|| format!("Expected `Boolean`, found: {v}"))
}
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S> {
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<S> {
// `Boolean`s are parsed separately, they shouldn't reach this code path.
Err(ParseError::UnexpectedToken(Token::Scalar(value)))
Err(ParseError::unexpected_token(Token::Scalar(value)))
}
}
@ -303,16 +295,16 @@ mod impl_int_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Int, String> {
v.as_int_value()
.ok_or_else(|| format!("Expected `Int`, found: {}", v))
.ok_or_else(|| format!("Expected `Int`, found: {v}"))
}
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S> {
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<S> {
if let ScalarToken::Int(v) = value {
v.parse()
.map_err(|_| ParseError::UnexpectedToken(Token::Scalar(value)))
.map_err(|_| ParseError::unexpected_token(Token::Scalar(value)))
.map(|s: i32| s.into())
} else {
Err(ParseError::UnexpectedToken(Token::Scalar(value)))
Err(ParseError::unexpected_token(Token::Scalar(value)))
}
}
}
@ -329,20 +321,20 @@ mod impl_float_scalar {
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Float, String> {
v.as_float_value()
.ok_or_else(|| format!("Expected `Float`, found: {}", v))
.ok_or_else(|| format!("Expected `Float`, found: {v}"))
}
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<'_, S> {
pub(super) fn parse_token<S: ScalarValue>(value: ScalarToken<'_>) -> ParseScalarResult<S> {
match value {
ScalarToken::Int(v) => v
.parse()
.map_err(|_| ParseError::UnexpectedToken(Token::Scalar(value)))
.map_err(|_| ParseError::unexpected_token(Token::Scalar(value)))
.map(|s: i32| f64::from(s).into()),
ScalarToken::Float(v) => v
.parse()
.map_err(|_| ParseError::UnexpectedToken(Token::Scalar(value)))
.map_err(|_| ParseError::unexpected_token(Token::Scalar(value)))
.map(|s: f64| s.into()),
ScalarToken::String(_) => Err(ParseError::UnexpectedToken(Token::Scalar(value))),
ScalarToken::String(_) => Err(ParseError::unexpected_token(Token::Scalar(value))),
}
}
}
@ -401,8 +393,9 @@ where
{
}
// Implemented manually to omit redundant `T: Default` trait bound, imposed by
// `#[derive(Default)]`.
impl<T> Default for EmptyMutation<T> {
#[inline]
fn default() -> Self {
Self::new()
}
@ -461,8 +454,9 @@ where
{
}
// Implemented manually to omit redundant `T: Default` trait bound, imposed by
// `#[derive(Default)]`.
impl<T> Default for EmptySubscription<T> {
#[inline]
fn default() -> Self {
Self::new()
}
@ -499,8 +493,8 @@ mod tests {
#[test]
fn test_id_display() {
let id = ID(String::from("foo"));
assert_eq!(format!("{}", id), "foo");
let id = ID("foo".into());
assert_eq!(id.to_string(), "foo");
}
#[test]
@ -508,7 +502,7 @@ mod tests {
fn parse_string(s: &str, expected: &str) {
let s =
<String as ParseScalarValue<DefaultScalarValue>>::from_str(ScalarToken::String(s));
assert!(s.is_ok(), "A parsing error occurred: {:?}", s);
assert!(s.is_ok(), "A parsing error occurred: {s:?}");
let s: Option<String> = s.unwrap().into();
assert!(s.is_some(), "No string returned");
assert_eq!(s.unwrap(), expected);
@ -527,7 +521,7 @@ mod tests {
#[test]
fn parse_f64_from_int() {
for (v, expected) in &[
for (v, expected) in [
("0", 0),
("128", 128),
("1601942400", 1601942400),
@ -538,14 +532,14 @@ mod tests {
assert!(n.is_ok(), "A parsing error occurred: {:?}", n.unwrap_err());
let n: Option<f64> = n.unwrap().into();
assert!(n.is_some(), "No f64 returned");
assert_eq!(n.unwrap(), f64::from(*expected));
assert!(n.is_some(), "No `f64` returned");
assert_eq!(n.unwrap(), f64::from(expected));
}
}
#[test]
fn parse_f64_from_float() {
for (v, expected) in &[
for (v, expected) in [
("0.", 0.),
("1.2", 1.2),
("1601942400.", 1601942400.),
@ -556,8 +550,8 @@ mod tests {
assert!(n.is_ok(), "A parsing error occurred: {:?}", n.unwrap_err());
let n: Option<f64> = n.unwrap().into();
assert!(n.is_some(), "No f64 returned");
assert_eq!(n.unwrap(), *expected);
assert!(n.is_some(), "No `f64` returned");
assert_eq!(n.unwrap(), expected);
}
}

4
juniper/src/types/str.rs
View file

@ -80,7 +80,7 @@ impl<SV: ScalarValue> resolve::InputValueAsRef<SV> for str {
fn try_from_input_value(v: &graphql::InputValue<SV>) -> Result<&Self, Self::Error> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {}", v))
.ok_or_else(|| format!("Expected `String`, found: {v}"))
}
}
@ -137,7 +137,7 @@ impl<SV> resolve::ScalarToken<SV> for str
where
String: resolve::ScalarToken<SV>,
{
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError<'_>> {
fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
<String as resolve::ScalarToken<SV>>::parse_scalar_token(token)
}
}

10
juniper/src/types/subscriptions.rs
View file

@ -94,8 +94,8 @@ pub trait SubscriptionConnection<S>: futures::Stream<Item = ExecutionOutput<S>>
///
/// See trait methods for more detailed explanation on how this trait works.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Subscription
/// [2]: https://spec.graphql.org/June2018/#sec-Objects
/// [1]: https://spec.graphql.org/October2021#sec-Subscription
/// [2]: https://spec.graphql.org/October2021#sec-Objects
pub trait GraphQLSubscriptionValue<S = DefaultScalarValue>: GraphQLValue<S> + Sync
where
Self::TypeInfo: Sync,
@ -204,7 +204,7 @@ crate::sa::assert_obj_safe!(GraphQLSubscriptionValue<Context = (), TypeInfo = ()
/// It's automatically implemented for [`GraphQLSubscriptionValue`] and [`GraphQLType`]
/// implementers, so doesn't require manual or code-generated implementation.
///
/// [1]: https://spec.graphql.org/June2018/#sec-Subscription
/// [1]: https://spec.graphql.org/October2021#sec-Subscription
pub trait GraphQLSubscriptionType<S = DefaultScalarValue>:
GraphQLSubscriptionValue<S> + GraphQLType<S>
where
@ -316,7 +316,9 @@ where
f.arguments.as_ref().map(|m| {
m.item
.iter()
.map(|&(ref k, ref v)| (k.item, v.item.clone().into_const(exec_vars)))
.filter_map(|&(ref k, ref v)| {
v.item.clone().into_const(exec_vars).map(|v| (k.item, v))
})
.collect()
}),
&meta_field.arguments,

3
juniper/src/types/utilities.rs
View file

@ -25,6 +25,7 @@ where
}
}
TypeType::List(ref inner, expected_size) => match *arg_value {
InputValue::Null | InputValue::Variable(_) => true,
InputValue::List(ref items) => {
if let Some(expected) = expected_size {
if items.len() != expected {
@ -71,7 +72,7 @@ where
let mut remaining_required_fields = input_fields
.iter()
.filter_map(|f| {
if f.arg_type.is_non_null() {
if f.arg_type.is_non_null() && f.default_value.is_none() {
Some(&f.name)
} else {
None

13
juniper/src/validation/context.rs
View file

@ -30,9 +30,9 @@ pub struct ValidatorContext<'a, S: Debug + 'a> {
impl RuleError {
#[doc(hidden)]
pub fn new(message: &str, locations: &[SourcePosition]) -> RuleError {
RuleError {
message: message.to_owned(),
pub fn new(message: &str, locations: &[SourcePosition]) -> Self {
Self {
message: message.into(),
locations: locations.to_vec(),
}
}
@ -53,14 +53,15 @@ impl RuleError {
impl fmt::Display for RuleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// this is fine since all `RuleError`s should have at least one source position
// This is fine since all `RuleError`s should have at least one source
// position.
let locations = self
.locations
.iter()
.map(|location| format!("{}", location))
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(", ");
write!(f, "{}. At {}", self.message, locations)
write!(f, "{}. At {locations}", self.message)
}
}

58
juniper/src/validation/input_value.rs
View file

@ -99,7 +99,7 @@ where
var_name,
var_pos,
&path,
&format!(r#"Expected "{}", found null"#, meta_type),
format!(r#"Expected "{meta_type}", found null"#),
));
} else {
errors.append(&mut unify_value(
@ -121,10 +121,10 @@ where
var_name,
var_pos,
&path,
&format!(
"Expected list of {} elements, found {} elements",
expected,
l.len()
format!(
"Expected list of {expected} elements, \
found {} elements",
l.len(),
),
));
}
@ -168,11 +168,11 @@ where
var_name,
var_pos,
&path,
&format!(
"Expected input of type `{}`. Got: `{}`. \
format!(
"Expected input of type `{}`. \
Got: `{value}`. \
Details: {}",
iom.name,
value,
e.message(),
),
));
@ -205,10 +205,9 @@ where
var_name,
var_pos,
path,
&format!(
"Expected input scalar `{}`. Got: `{}`. Details: {}",
format!(
"Expected input scalar `{}`. Got: `{value}`. Details: {}",
meta.name,
value,
e.message(),
),
)];
@ -219,13 +218,13 @@ where
var_name,
var_pos,
path,
&format!(r#"Expected "{}", found list"#, meta.name),
format!(r#"Expected "{}", found list"#, meta.name),
)),
InputValue::Object(_) => errors.push(unification_error(
var_name,
var_pos,
path,
&format!(r#"Expected "{}", found object"#, meta.name),
format!(r#"Expected "{}", found object"#, meta.name),
)),
_ => (),
}
@ -244,27 +243,27 @@ where
{
let mut errors: Vec<RuleError> = vec![];
match *value {
match value {
// TODO: avoid this bad duplicate as_str() call. (value system refactor)
InputValue::Scalar(ref scalar) if scalar.as_str().is_some() => {
InputValue::Scalar(scalar) if scalar.as_str().is_some() => {
if let Some(name) = scalar.as_str() {
if !meta.values.iter().any(|ev| ev.name == *name) {
errors.push(unification_error(
var_name,
var_pos,
path,
&format!(r#"Invalid value for enum "{}""#, meta.name),
format!(r#"Invalid value for enum "{}""#, meta.name),
))
}
}
}
InputValue::Enum(ref name) => {
InputValue::Enum(name) => {
if !meta.values.iter().any(|ev| &ev.name == name) {
errors.push(unification_error(
var_name,
var_pos,
path,
&format!(r#"Invalid value for enum "{}""#, meta.name),
format!(r#"Invalid value for enum "{}""#, meta.name),
))
}
}
@ -272,7 +271,7 @@ where
var_name,
var_pos,
path,
&format!(r#"Expected "{}", found not a string or enum"#, meta.name),
format!(r#"Expected "{}", found not a string or enum"#, meta.name),
)),
}
errors
@ -318,7 +317,7 @@ where
var_name,
var_pos,
&Path::ObjectField(&input_field.name, path),
&format!(r#"Expected "{}", found null"#, input_field.arg_type),
format!(r#"Expected "{}", found null"#, input_field.arg_type),
));
}
}
@ -336,7 +335,7 @@ where
var_name,
var_pos,
path,
&format!(r#"Expected "{}", found not an object"#, meta.name),
format!(r#"Expected "{}", found not an object"#, meta.name),
));
}
errors
@ -349,17 +348,14 @@ where
v.map_or(true, InputValue::is_null)
}
fn unification_error<'a>(
var_name: &str,
fn unification_error(
var_name: impl fmt::Display,
var_pos: &SourcePosition,
path: &Path<'a>,
message: &str,
path: &Path<'_>,
message: impl fmt::Display,
) -> RuleError {
RuleError::new(
&format!(
r#"Variable "${}" got invalid value. {}{}."#,
var_name, path, message,
),
&format!(r#"Variable "${var_name}" got invalid value. {path}{message}."#),
&[*var_pos],
)
}
@ -368,8 +364,8 @@ impl<'a> fmt::Display for Path<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Path::Root => write!(f, ""),
Path::ArrayElement(idx, prev) => write!(f, "{}In element #{}: ", prev, idx),
Path::ObjectField(name, prev) => write!(f, r#"{}In field "{}": "#, prev, name),
Path::ArrayElement(idx, prev) => write!(f, "{prev}In element #{idx}: "),
Path::ObjectField(name, prev) => write!(f, r#"{prev}In field "{name}": "#),
}
}
}

50
juniper/src/validation/rules/arguments_of_correct_type.rs
View file

@ -1,3 +1,5 @@
use std::fmt;
use crate::{
ast::{Directive, Field, InputValue},
parser::Spanning,
@ -6,13 +8,12 @@ use crate::{
validation::{ValidatorContext, Visitor},
value::ScalarValue,
};
use std::fmt::Debug;
pub struct ArgumentsOfCorrectType<'a, S: Debug + 'a> {
pub struct ArgumentsOfCorrectType<'a, S: fmt::Debug + 'a> {
current_args: Option<&'a Vec<Argument<'a, S>>>,
}
pub fn factory<'a, S: Debug>() -> ArgumentsOfCorrectType<'a, S> {
pub fn factory<'a, S: fmt::Debug>() -> ArgumentsOfCorrectType<'a, S> {
ArgumentsOfCorrectType { current_args: None }
}
@ -59,7 +60,7 @@ where
if !is_valid_literal_value(ctx.schema, &meta_type, &arg_value.item) {
ctx.report_error(
&error_message(arg_name.item, &format!("{}", argument_meta.arg_type)),
&error_message(arg_name.item, &argument_meta.arg_type),
&[arg_value.start],
);
}
@ -67,11 +68,8 @@ where
}
}
fn error_message(arg_name: &str, type_name: &str) -> String {
format!(
"Invalid value for argument \"{}\", expected type \"{}\"",
arg_name, type_name
)
fn error_message(arg_name: impl fmt::Display, type_name: impl fmt::Display) -> String {
format!("Invalid value for argument \"{arg_name}\", expected type \"{type_name}\"",)
}
#[cfg(test)]
@ -85,7 +83,7 @@ mod tests {
};
#[test]
fn good_null_value() {
fn null_into_nullable_int() {
expect_passes_rule::<_, _, DefaultScalarValue>(
factory,
r#"
@ -98,6 +96,20 @@ mod tests {
);
}
#[test]
fn null_into_nullable_list() {
expect_passes_rule::<_, _, DefaultScalarValue>(
factory,
r#"
{
complicatedArgs {
stringListArgField(stringListArg: null)
}
}
"#,
);
}
#[test]
fn null_into_int() {
expect_fails_rule::<_, _, DefaultScalarValue>(
@ -116,6 +128,24 @@ mod tests {
);
}
#[test]
fn null_into_list() {
expect_fails_rule::<_, _, DefaultScalarValue>(
factory,
r#"
{
complicatedArgs {
nonNullStringListArgField(nonNullStringListArg: null)
}
}
"#,
&[RuleError::new(
&error_message("nonNullStringListArg", "[String!]!"),
&[SourcePosition::new(111, 3, 64)],
)],
);
}
#[test]
fn good_int_value() {
expect_passes_rule::<_, _, DefaultScalarValue>(

19
juniper/src/validation/rules/default_values_of_correct_type.rs
View file

@ -1,3 +1,5 @@
use std::fmt;
use crate::{
ast::VariableDefinition,
parser::Spanning,
@ -29,7 +31,7 @@ where
{
if var_def.var_type.item.is_non_null() {
ctx.report_error(
&non_null_error_message(var_name.item, &format!("{}", var_def.var_type.item)),
&non_null_error_message(var_name.item, &var_def.var_type.item),
&[*start],
)
} else {
@ -37,7 +39,7 @@ where
if !is_valid_literal_value(ctx.schema, &meta_type, var_value) {
ctx.report_error(
&type_error_message(var_name.item, &format!("{}", var_def.var_type.item)),
&type_error_message(var_name.item, &var_def.var_type.item),
&[*start],
);
}
@ -46,17 +48,14 @@ where
}
}
fn type_error_message(arg_name: &str, type_name: &str) -> String {
format!(
"Invalid default value for argument \"{}\", expected type \"{}\"",
arg_name, type_name
)
fn type_error_message(arg_name: impl fmt::Display, type_name: impl fmt::Display) -> String {
format!("Invalid default value for argument \"{arg_name}\", expected type \"{type_name}\"")
}
fn non_null_error_message(arg_name: &str, type_name: &str) -> String {
fn non_null_error_message(arg_name: impl fmt::Display, type_name: impl fmt::Display) -> String {
format!(
"Argument \"{}\" has type \"{}\" and is not nullable, so it can't have a default value",
arg_name, type_name
"Argument \"{arg_name}\" has type \"{type_name}\" and is not nullable, \
so it can't have a default value",
)
}

2
juniper/src/validation/rules/fields_on_correct_type.rs
View file

@ -69,7 +69,7 @@ where
}
fn error_message(field: &str, type_name: &str) -> String {
format!(r#"Unknown field "{}" on type "{}""#, field, type_name)
format!(r#"Unknown field "{field}" on type "{type_name}""#)
}
#[cfg(test)]

Some files were not shown because too many files have changed in this diff Show more