2018-09-24 05:07:44 -05:00
|
|
|
#![doc(html_root_url = "https://docs.rs/juniper_hyper/0.2.0")]
|
|
|
|
|
|
2018-09-01 22:02:01 -05:00
|
|
|
#[cfg(test)]
|
|
|
|
|
extern crate reqwest;
|
|
|
|
|
|
2019-08-21 08:23:53 -05:00
|
|
|
use hyper::{
|
|
|
|
|
header::{self, HeaderValue},
|
|
|
|
|
Body, Method, Request, Response, StatusCode,
|
|
|
|
|
};
|
|
|
|
|
use juniper::{
|
|
|
|
|
http::GraphQLRequest as JuniperGraphQLRequest, serde::Deserialize, DefaultScalarValue,
|
2020-03-09 01:20:11 -05:00
|
|
|
GraphQLType, GraphQLTypeAsync, InputValue, RootNode, ScalarValue,
|
2019-08-21 08:23:53 -05:00
|
|
|
};
|
2018-09-01 22:02:01 -05:00
|
|
|
use serde_json::error::Error as SerdeError;
|
2019-08-21 08:23:53 -05:00
|
|
|
use std::{error::Error, fmt, string::FromUtf8Error, sync::Arc};
|
2018-09-01 22:02:01 -05:00
|
|
|
use url::form_urlencoded;
|
|
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
pub async fn graphql<CtxT, QueryT, MutationT, S>(
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
root_node: Arc<RootNode<'static, QueryT, MutationT, S>>,
|
2018-09-01 22:02:01 -05:00
|
|
|
context: Arc<CtxT>,
|
|
|
|
|
request: Request<Body>,
|
2020-02-13 00:48:28 -06:00
|
|
|
) -> Result<Response<Body>, hyper::Error>
|
2018-09-01 22:02:01 -05:00
|
|
|
where
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
S: ScalarValue + Send + Sync + 'static,
|
2018-09-01 22:02:01 -05:00
|
|
|
CtxT: Send + Sync + 'static,
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
QueryT: GraphQLType<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
MutationT: GraphQLType<S, Context = CtxT> + Send + Sync + 'static,
|
2018-09-01 22:02:01 -05:00
|
|
|
QueryT::TypeInfo: Send + Sync,
|
|
|
|
|
MutationT::TypeInfo: Send + Sync,
|
|
|
|
|
{
|
2020-03-14 00:03:36 -05:00
|
|
|
match *request.method() {
|
|
|
|
|
Method::GET => {
|
2020-02-13 00:48:28 -06:00
|
|
|
let gql_req = parse_get_req(request);
|
|
|
|
|
|
|
|
|
|
match gql_req {
|
|
|
|
|
Ok(gql_req) => Ok(execute_request(root_node, context, gql_req).await),
|
|
|
|
|
Err(err) => Ok(render_error(err)),
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-14 00:03:36 -05:00
|
|
|
Method::POST => {
|
2020-02-13 00:48:28 -06:00
|
|
|
let gql_req = parse_post_req(request.into_body()).await;
|
|
|
|
|
|
|
|
|
|
match gql_req {
|
|
|
|
|
Ok(gql_req) => Ok(execute_request(root_node, context, gql_req).await),
|
|
|
|
|
Err(err) => Ok(render_error(err)),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
_ => Ok(new_response(StatusCode::METHOD_NOT_ALLOWED)),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub async fn graphql_async<CtxT, QueryT, MutationT, S>(
|
|
|
|
|
root_node: Arc<RootNode<'static, QueryT, MutationT, S>>,
|
|
|
|
|
context: Arc<CtxT>,
|
|
|
|
|
request: Request<Body>,
|
|
|
|
|
) -> Result<Response<Body>, hyper::Error>
|
|
|
|
|
where
|
|
|
|
|
S: ScalarValue + Send + Sync + 'static,
|
|
|
|
|
CtxT: Send + Sync + 'static,
|
|
|
|
|
QueryT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
MutationT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
QueryT::TypeInfo: Send + Sync,
|
|
|
|
|
MutationT::TypeInfo: Send + Sync,
|
|
|
|
|
{
|
2020-03-14 00:03:36 -05:00
|
|
|
match *request.method() {
|
|
|
|
|
Method::GET => {
|
2020-02-13 00:48:28 -06:00
|
|
|
let gql_req = parse_get_req(request);
|
|
|
|
|
|
|
|
|
|
match gql_req {
|
|
|
|
|
Ok(gql_req) => Ok(execute_request_async(root_node, context, gql_req).await),
|
|
|
|
|
Err(err) => Ok(render_error(err)),
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-14 00:03:36 -05:00
|
|
|
Method::POST => {
|
2020-02-13 00:48:28 -06:00
|
|
|
let gql_req = parse_post_req(request.into_body()).await;
|
|
|
|
|
|
|
|
|
|
match gql_req {
|
|
|
|
|
Ok(gql_req) => Ok(execute_request_async(root_node, context, gql_req).await),
|
|
|
|
|
Err(err) => Ok(render_error(err)),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
_ => Ok(new_response(StatusCode::METHOD_NOT_ALLOWED)),
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
fn parse_get_req<S: ScalarValue>(
|
|
|
|
|
req: Request<Body>,
|
|
|
|
|
) -> Result<GraphQLRequest<S>, GraphQLRequestError> {
|
|
|
|
|
req.uri()
|
|
|
|
|
.query()
|
|
|
|
|
.map(|q| gql_request_from_get(q).map(GraphQLRequest::Single))
|
|
|
|
|
.unwrap_or_else(|| {
|
|
|
|
|
Err(GraphQLRequestError::Invalid(
|
|
|
|
|
"'query' parameter is missing".to_string(),
|
|
|
|
|
))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn parse_post_req<S: ScalarValue>(
|
|
|
|
|
body: Body,
|
|
|
|
|
) -> Result<GraphQLRequest<S>, GraphQLRequestError> {
|
|
|
|
|
let chunk = hyper::body::to_bytes(body)
|
|
|
|
|
.await
|
2020-03-14 00:03:36 -05:00
|
|
|
.map_err(GraphQLRequestError::BodyHyper)?;
|
2020-02-13 00:48:28 -06:00
|
|
|
|
|
|
|
|
let input = String::from_utf8(chunk.iter().cloned().collect())
|
|
|
|
|
.map_err(GraphQLRequestError::BodyUtf8)?;
|
|
|
|
|
|
|
|
|
|
serde_json::from_str::<GraphQLRequest<S>>(&input).map_err(GraphQLRequestError::BodyJSONError)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub async fn graphiql(graphql_endpoint: &str) -> Result<Response<Body>, hyper::Error> {
|
2018-09-01 22:02:01 -05:00
|
|
|
let mut resp = new_html_response(StatusCode::OK);
|
2018-09-30 13:07:44 -05:00
|
|
|
// XXX: is the call to graphiql_source blocking?
|
2018-09-01 22:02:01 -05:00
|
|
|
*resp.body_mut() = Body::from(juniper::graphiql::graphiql_source(graphql_endpoint));
|
2020-02-13 00:48:28 -06:00
|
|
|
Ok(resp)
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
pub async fn playground(graphql_endpoint: &str) -> Result<Response<Body>, hyper::Error> {
|
2019-01-25 22:58:01 -06:00
|
|
|
let mut resp = new_html_response(StatusCode::OK);
|
|
|
|
|
*resp.body_mut() = Body::from(juniper::http::playground::playground_source(
|
|
|
|
|
graphql_endpoint,
|
|
|
|
|
));
|
2020-02-13 00:48:28 -06:00
|
|
|
Ok(resp)
|
2019-01-25 22:58:01 -06:00
|
|
|
}
|
|
|
|
|
|
2018-09-01 22:02:01 -05:00
|
|
|
fn render_error(err: GraphQLRequestError) -> Response<Body> {
|
|
|
|
|
let message = format!("{}", err);
|
|
|
|
|
let mut resp = new_response(StatusCode::BAD_REQUEST);
|
|
|
|
|
*resp.body_mut() = Body::from(message);
|
|
|
|
|
resp
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
async fn execute_request<CtxT, QueryT, MutationT, S>(
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
root_node: Arc<RootNode<'static, QueryT, MutationT, S>>,
|
2018-09-01 22:02:01 -05:00
|
|
|
context: Arc<CtxT>,
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
request: GraphQLRequest<S>,
|
2020-02-13 00:48:28 -06:00
|
|
|
) -> Response<Body>
|
2018-09-01 22:02:01 -05:00
|
|
|
where
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
S: ScalarValue + Send + Sync + 'static,
|
2018-09-01 22:02:01 -05:00
|
|
|
CtxT: Send + Sync + 'static,
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
QueryT: GraphQLType<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
MutationT: GraphQLType<S, Context = CtxT> + Send + Sync + 'static,
|
2018-09-01 22:02:01 -05:00
|
|
|
QueryT::TypeInfo: Send + Sync,
|
|
|
|
|
MutationT::TypeInfo: Send + Sync,
|
|
|
|
|
{
|
2020-03-10 00:40:26 -05:00
|
|
|
let (is_ok, body) = request.execute_sync(root_node, context);
|
2020-02-13 00:48:28 -06:00
|
|
|
let code = if is_ok {
|
|
|
|
|
StatusCode::OK
|
|
|
|
|
} else {
|
|
|
|
|
StatusCode::BAD_REQUEST
|
|
|
|
|
};
|
|
|
|
|
let mut resp = new_response(code);
|
|
|
|
|
resp.headers_mut().insert(
|
|
|
|
|
header::CONTENT_TYPE,
|
|
|
|
|
HeaderValue::from_static("application/json"),
|
|
|
|
|
);
|
|
|
|
|
*resp.body_mut() = body;
|
|
|
|
|
resp
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn execute_request_async<CtxT, QueryT, MutationT, S>(
|
|
|
|
|
root_node: Arc<RootNode<'static, QueryT, MutationT, S>>,
|
|
|
|
|
context: Arc<CtxT>,
|
|
|
|
|
request: GraphQLRequest<S>,
|
|
|
|
|
) -> Response<Body>
|
|
|
|
|
where
|
|
|
|
|
S: ScalarValue + Send + Sync + 'static,
|
|
|
|
|
CtxT: Send + Sync + 'static,
|
|
|
|
|
QueryT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
MutationT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync + 'static,
|
|
|
|
|
QueryT::TypeInfo: Send + Sync,
|
|
|
|
|
MutationT::TypeInfo: Send + Sync,
|
|
|
|
|
{
|
2020-03-10 00:40:26 -05:00
|
|
|
let (is_ok, body) = request.execute(root_node, context).await;
|
2020-02-13 00:48:28 -06:00
|
|
|
let code = if is_ok {
|
|
|
|
|
StatusCode::OK
|
|
|
|
|
} else {
|
|
|
|
|
StatusCode::BAD_REQUEST
|
|
|
|
|
};
|
|
|
|
|
let mut resp = new_response(code);
|
|
|
|
|
resp.headers_mut().insert(
|
|
|
|
|
header::CONTENT_TYPE,
|
|
|
|
|
HeaderValue::from_static("application/json"),
|
|
|
|
|
);
|
|
|
|
|
*resp.body_mut() = body;
|
|
|
|
|
resp
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
fn gql_request_from_get<S>(input: &str) -> Result<JuniperGraphQLRequest<S>, GraphQLRequestError>
|
|
|
|
|
where
|
|
|
|
|
S: ScalarValue,
|
|
|
|
|
{
|
2018-09-01 22:02:01 -05:00
|
|
|
let mut query = None;
|
|
|
|
|
let operation_name = None;
|
|
|
|
|
let mut variables = None;
|
|
|
|
|
for (key, value) in form_urlencoded::parse(input.as_bytes()).into_owned() {
|
|
|
|
|
match key.as_ref() {
|
|
|
|
|
"query" => {
|
|
|
|
|
if query.is_some() {
|
|
|
|
|
return Err(invalid_err("query"));
|
|
|
|
|
}
|
|
|
|
|
query = Some(value)
|
|
|
|
|
}
|
|
|
|
|
"operationName" => {
|
|
|
|
|
if operation_name.is_some() {
|
|
|
|
|
return Err(invalid_err("operationName"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
"variables" => {
|
|
|
|
|
if variables.is_some() {
|
|
|
|
|
return Err(invalid_err("variables"));
|
|
|
|
|
}
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
match serde_json::from_str::<InputValue<S>>(&value)
|
2018-09-01 22:02:01 -05:00
|
|
|
.map_err(GraphQLRequestError::Variables)
|
|
|
|
|
{
|
|
|
|
|
Ok(parsed_variables) => variables = Some(parsed_variables),
|
|
|
|
|
Err(e) => return Err(e),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
_ => continue,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
match query {
|
|
|
|
|
Some(query) => Ok(JuniperGraphQLRequest::new(query, operation_name, variables)),
|
|
|
|
|
None => Err(GraphQLRequestError::Invalid(
|
|
|
|
|
"'query' parameter is missing".to_string(),
|
|
|
|
|
)),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn invalid_err(parameter_name: &str) -> GraphQLRequestError {
|
|
|
|
|
GraphQLRequestError::Invalid(format!(
|
|
|
|
|
"'{}' parameter is specified multiple times",
|
|
|
|
|
parameter_name
|
|
|
|
|
))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn new_response(code: StatusCode) -> Response<Body> {
|
|
|
|
|
let mut r = Response::new(Body::empty());
|
|
|
|
|
*r.status_mut() = code;
|
|
|
|
|
r
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn new_html_response(code: StatusCode) -> Response<Body> {
|
|
|
|
|
let mut resp = new_response(code);
|
|
|
|
|
resp.headers_mut().insert(
|
|
|
|
|
header::CONTENT_TYPE,
|
|
|
|
|
HeaderValue::from_static("text/html; charset=utf-8"),
|
|
|
|
|
);
|
|
|
|
|
resp
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-22 19:19:06 -05:00
|
|
|
#[derive(serde_derive::Deserialize)]
|
2018-09-01 22:02:01 -05:00
|
|
|
#[serde(untagged)]
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
#[serde(bound = "InputValue<S>: Deserialize<'de>")]
|
|
|
|
|
enum GraphQLRequest<S = DefaultScalarValue>
|
|
|
|
|
where
|
|
|
|
|
S: ScalarValue,
|
|
|
|
|
{
|
|
|
|
|
Single(JuniperGraphQLRequest<S>),
|
|
|
|
|
Batch(Vec<JuniperGraphQLRequest<S>>),
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
impl<S> GraphQLRequest<S>
|
|
|
|
|
where
|
|
|
|
|
S: ScalarValue,
|
|
|
|
|
{
|
2020-03-10 00:40:26 -05:00
|
|
|
fn execute_sync<'a, CtxT: 'a, QueryT, MutationT>(
|
2018-09-30 13:07:44 -05:00
|
|
|
self,
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
root_node: Arc<RootNode<'a, QueryT, MutationT, S>>,
|
2018-09-30 13:07:44 -05:00
|
|
|
context: Arc<CtxT>,
|
2020-02-13 00:48:28 -06:00
|
|
|
) -> (bool, hyper::Body)
|
2018-09-01 22:02:01 -05:00
|
|
|
where
|
2020-02-13 00:48:28 -06:00
|
|
|
S: 'a + Send + Sync,
|
Introduce an abstraction for scalar values (#251)
Introduce an abstraction for scalar values
Before this change, possible scalar values were hard coded to be representable
by one of the following types: `i32`, `f64`, `String` or `bool`. This
restricts the types of custom scalar values that can be defined. For
example, it was not possible to define a scalar value that represents an
`i64` without mapping it to a string (which would be inefficient).
One solution to fix the example above would simply be to change the
internal representation to allow it to represent an `i64`, but this would
only fix the problem for one type (until someone wants to support
`i128` for example). Also this would make juniper not follow the
GraphQL standard closely.
This commit takes another approach, by making the exact "internal"
representation of scalar values swappable (in such a way that a downstream crate could provide its own representation tailored to their needs). This allows juniper to provide a default type that only
contains the types described in the standard whereas other crates could define custom scalars for their needs.
To accomplish this we need to change several things in the current implementation:
* Add some traits that abstract the behavior of such a scalar value representation
* Change `Value` and `InputValue` to have a scalar variant (with a
generic type) instead of hard coded variants for the standard
types. This implies adding a generic parameter to both enums that
needs to be added in the whole crate.
* Change the parser to allow deciding between different types of
scalar values. The problem is basically that the original parser
implementation had no way to know whether a parsed integer number is
a `i32` or a `i64` (for example). To fix this we added some knowledge
of the existing schema to the parser.
* Fix some macros and derives to follow the new behavior.
This commit also contains an unrelated change about the way `juniper_codegen`
resolves items from `juniper`. The `_internal` flag is removed and
the resolution is replaced by a macro.
The scalar parsing strategy is as follows:
* Pass optional type information all the way down in the parser. If a
field/type/… does note exist, just do not pass down the type
information.
* The lexer now distinguishes between several fundamental scalar types (`String`, `Float`, `Int`). It does not try to actually parse those values, instead it just annotates them that this is a floating point number, an integer number, or a string value, etc.
* If type information exists while parsing a scalar value, try the following:
1. Try parsing the value using that type information.
2. If that fails try parsing the value using the inferred type information from the lexer.
* If no type information exists, try parsing the scalar value using the inferred type from the lexer,
All macros support the introduced scalar value abstraction. It is now possible to specify if a certain implementation should be based on a specific scalar value representation or be generic about the exact representation. All macros now default to the `DefaultScalarValue` type provided by
`juniper` if no scalar value representation is specified. This is done with usability and backwards compatibility in mind.
Finally, we allow specifying the scalar value representations via an attribute
(`#[graphql(scalar = "Type")]`). A default generic implementation
is provided.
2018-10-22 22:40:14 -05:00
|
|
|
QueryT: GraphQLType<S, Context = CtxT> + 'a,
|
|
|
|
|
MutationT: GraphQLType<S, Context = CtxT> + 'a,
|
2018-09-01 22:02:01 -05:00
|
|
|
{
|
|
|
|
|
match self {
|
2020-02-13 00:48:28 -06:00
|
|
|
GraphQLRequest::Single(request) => {
|
2020-03-10 00:40:26 -05:00
|
|
|
let res = request.execute_sync(&root_node, &context);
|
2018-09-30 13:07:44 -05:00
|
|
|
let is_ok = res.is_ok();
|
|
|
|
|
let body = Body::from(serde_json::to_string_pretty(&res).unwrap());
|
2020-02-13 00:48:28 -06:00
|
|
|
(is_ok, body)
|
|
|
|
|
}
|
2018-09-30 13:07:44 -05:00
|
|
|
GraphQLRequest::Batch(requests) => {
|
2020-02-13 00:48:28 -06:00
|
|
|
let results: Vec<_> = requests
|
|
|
|
|
.into_iter()
|
|
|
|
|
.map(move |request| {
|
2018-09-30 13:07:44 -05:00
|
|
|
let root_node = root_node.clone();
|
2020-03-10 00:40:26 -05:00
|
|
|
let res = request.execute_sync(&root_node, &context);
|
2020-02-13 00:48:28 -06:00
|
|
|
let is_ok = res.is_ok();
|
|
|
|
|
let body = serde_json::to_string_pretty(&res).unwrap();
|
2018-09-30 13:07:44 -05:00
|
|
|
(is_ok, body)
|
2020-02-13 00:48:28 -06:00
|
|
|
})
|
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
|
|
let is_ok = !results.iter().any(|&(is_ok, _)| !is_ok);
|
|
|
|
|
let bodies: Vec<_> = results.into_iter().map(|(_, body)| body).collect();
|
|
|
|
|
let body = hyper::Body::from(format!("[{}]", bodies.join(",")));
|
|
|
|
|
(is_ok, body)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-10 00:40:26 -05:00
|
|
|
async fn execute<'a, CtxT: 'a, QueryT, MutationT>(
|
2020-02-13 00:48:28 -06:00
|
|
|
self,
|
|
|
|
|
root_node: Arc<RootNode<'a, QueryT, MutationT, S>>,
|
|
|
|
|
context: Arc<CtxT>,
|
|
|
|
|
) -> (bool, hyper::Body)
|
|
|
|
|
where
|
|
|
|
|
S: Send + Sync,
|
|
|
|
|
QueryT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync,
|
|
|
|
|
MutationT: GraphQLTypeAsync<S, Context = CtxT> + Send + Sync,
|
|
|
|
|
QueryT::TypeInfo: Send + Sync,
|
|
|
|
|
MutationT::TypeInfo: Send + Sync,
|
|
|
|
|
CtxT: Send + Sync,
|
|
|
|
|
{
|
|
|
|
|
match self {
|
|
|
|
|
GraphQLRequest::Single(request) => {
|
2020-03-10 00:40:26 -05:00
|
|
|
let res = request.execute(&root_node, &context).await;
|
2020-02-13 00:48:28 -06:00
|
|
|
let is_ok = res.is_ok();
|
|
|
|
|
let body = Body::from(serde_json::to_string_pretty(&res).unwrap());
|
|
|
|
|
(is_ok, body)
|
|
|
|
|
}
|
|
|
|
|
GraphQLRequest::Batch(requests) => {
|
|
|
|
|
let futures = requests
|
|
|
|
|
.iter()
|
2020-03-10 00:40:26 -05:00
|
|
|
.map(|request| request.execute(&root_node, &context))
|
2020-02-13 00:48:28 -06:00
|
|
|
.collect::<Vec<_>>();
|
|
|
|
|
let results = futures::future::join_all(futures).await;
|
|
|
|
|
|
|
|
|
|
let is_ok = results.iter().all(|res| res.is_ok());
|
|
|
|
|
let bodies: Vec<_> = results
|
|
|
|
|
.into_iter()
|
|
|
|
|
.map(|res| serde_json::to_string_pretty(&res).unwrap())
|
|
|
|
|
.collect();
|
|
|
|
|
let body = hyper::Body::from(format!("[{}]", bodies.join(",")));
|
|
|
|
|
(is_ok, body)
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
|
enum GraphQLRequestError {
|
|
|
|
|
BodyHyper(hyper::Error),
|
|
|
|
|
BodyUtf8(FromUtf8Error),
|
|
|
|
|
BodyJSONError(SerdeError),
|
|
|
|
|
Variables(SerdeError),
|
|
|
|
|
Invalid(String),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl fmt::Display for GraphQLRequestError {
|
|
|
|
|
fn fmt(&self, mut f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
|
match *self {
|
|
|
|
|
GraphQLRequestError::BodyHyper(ref err) => fmt::Display::fmt(err, &mut f),
|
|
|
|
|
GraphQLRequestError::BodyUtf8(ref err) => fmt::Display::fmt(err, &mut f),
|
|
|
|
|
GraphQLRequestError::BodyJSONError(ref err) => fmt::Display::fmt(err, &mut f),
|
|
|
|
|
GraphQLRequestError::Variables(ref err) => fmt::Display::fmt(err, &mut f),
|
|
|
|
|
GraphQLRequestError::Invalid(ref err) => fmt::Display::fmt(err, &mut f),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Error for GraphQLRequestError {
|
2020-03-09 02:12:57 -05:00
|
|
|
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
2018-09-01 22:02:01 -05:00
|
|
|
match *self {
|
|
|
|
|
GraphQLRequestError::BodyHyper(ref err) => Some(err),
|
|
|
|
|
GraphQLRequestError::BodyUtf8(ref err) => Some(err),
|
|
|
|
|
GraphQLRequestError::BodyJSONError(ref err) => Some(err),
|
|
|
|
|
GraphQLRequestError::Variables(ref err) => Some(err),
|
|
|
|
|
GraphQLRequestError::Invalid(_) => None,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-09 01:20:11 -05:00
|
|
|
|
2018-09-01 22:02:01 -05:00
|
|
|
#[cfg(test)]
|
|
|
|
|
mod tests {
|
2020-02-13 00:48:28 -06:00
|
|
|
use futures;
|
|
|
|
|
use hyper::{
|
|
|
|
|
service::{make_service_fn, service_fn},
|
|
|
|
|
Body, Method, Response, Server, StatusCode,
|
2019-08-21 08:23:53 -05:00
|
|
|
};
|
|
|
|
|
use juniper::{
|
|
|
|
|
http::tests as http_tests,
|
|
|
|
|
tests::{model::Database, schema::Query},
|
|
|
|
|
EmptyMutation, RootNode,
|
|
|
|
|
};
|
|
|
|
|
use reqwest::{self, Response as ReqwestResponse};
|
2020-02-13 00:48:28 -06:00
|
|
|
use std::{net::SocketAddr, sync::Arc, thread, time::Duration};
|
2018-09-01 22:02:01 -05:00
|
|
|
|
|
|
|
|
struct TestHyperIntegration;
|
|
|
|
|
|
|
|
|
|
impl http_tests::HTTPIntegration for TestHyperIntegration {
|
|
|
|
|
fn get(&self, url: &str) -> http_tests::TestResponse {
|
|
|
|
|
let url = format!("http://127.0.0.1:3001/graphql{}", url);
|
|
|
|
|
make_test_response(reqwest::get(&url).expect(&format!("failed GET {}", url)))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn post(&self, url: &str, body: &str) -> http_tests::TestResponse {
|
|
|
|
|
let url = format!("http://127.0.0.1:3001/graphql{}", url);
|
|
|
|
|
let client = reqwest::Client::new();
|
|
|
|
|
let res = client
|
|
|
|
|
.post(&url)
|
|
|
|
|
.body(body.to_string())
|
|
|
|
|
.send()
|
|
|
|
|
.expect(&format!("failed POST {}", url));
|
|
|
|
|
make_test_response(res)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn make_test_response(mut response: ReqwestResponse) -> http_tests::TestResponse {
|
|
|
|
|
let status_code = response.status().as_u16() as i32;
|
|
|
|
|
let body = response.text().unwrap();
|
2018-09-30 13:07:44 -05:00
|
|
|
let content_type_header = response.headers().get(reqwest::header::CONTENT_TYPE);
|
2018-09-13 12:06:03 -05:00
|
|
|
let content_type = if let Some(ct) = content_type_header {
|
2018-09-30 13:07:44 -05:00
|
|
|
format!("{}", ct.to_str().unwrap())
|
2018-09-13 12:06:03 -05:00
|
|
|
} else {
|
|
|
|
|
String::default()
|
|
|
|
|
};
|
2018-09-01 22:02:01 -05:00
|
|
|
|
|
|
|
|
http_tests::TestResponse {
|
|
|
|
|
status_code,
|
|
|
|
|
body: Some(body),
|
|
|
|
|
content_type,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
#[tokio::test]
|
|
|
|
|
async fn test_hyper_integration() {
|
|
|
|
|
let addr: SocketAddr = ([127, 0, 0, 1], 3001).into();
|
2018-09-01 22:02:01 -05:00
|
|
|
|
|
|
|
|
let db = Arc::new(Database::new());
|
2019-05-18 11:07:51 -05:00
|
|
|
let root_node = Arc::new(RootNode::new(Query, EmptyMutation::<Database>::new()));
|
2018-09-01 22:02:01 -05:00
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
let new_service = make_service_fn(move |_| {
|
2018-09-01 22:02:01 -05:00
|
|
|
let root_node = root_node.clone();
|
|
|
|
|
let ctx = db.clone();
|
2020-02-13 00:48:28 -06:00
|
|
|
|
|
|
|
|
async move {
|
|
|
|
|
Ok::<_, hyper::Error>(service_fn(move |req| {
|
|
|
|
|
let root_node = root_node.clone();
|
|
|
|
|
let ctx = ctx.clone();
|
|
|
|
|
let matches = {
|
|
|
|
|
let path = req.uri().path();
|
|
|
|
|
match req.method() {
|
|
|
|
|
&Method::POST | &Method::GET => {
|
|
|
|
|
path == "/graphql" || path == "/graphql/"
|
|
|
|
|
}
|
|
|
|
|
_ => false,
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
async move {
|
|
|
|
|
if matches {
|
|
|
|
|
super::graphql(root_node, ctx, req).await
|
|
|
|
|
} else {
|
|
|
|
|
let mut response = Response::new(Body::empty());
|
|
|
|
|
*response.status_mut() = StatusCode::NOT_FOUND;
|
|
|
|
|
Ok(response)
|
|
|
|
|
}
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
2020-02-13 00:48:28 -06:00
|
|
|
}))
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
let (shutdown_fut, shutdown) = futures::future::abortable(async {
|
|
|
|
|
tokio::time::delay_for(Duration::from_secs(60)).await;
|
|
|
|
|
});
|
|
|
|
|
|
2018-09-01 22:02:01 -05:00
|
|
|
let server = Server::bind(&addr)
|
|
|
|
|
.serve(new_service)
|
2020-02-13 00:48:28 -06:00
|
|
|
.with_graceful_shutdown(async {
|
|
|
|
|
shutdown_fut.await.unwrap_err();
|
|
|
|
|
});
|
2018-09-01 22:02:01 -05:00
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
tokio::task::spawn_blocking(move || {
|
|
|
|
|
thread::sleep(Duration::from_millis(10)); // wait 10ms for server to bind
|
|
|
|
|
let integration = TestHyperIntegration;
|
|
|
|
|
http_tests::run_http_test_suite(&integration);
|
|
|
|
|
shutdown.abort();
|
|
|
|
|
});
|
2018-09-01 22:02:01 -05:00
|
|
|
|
2020-02-13 00:48:28 -06:00
|
|
|
if let Err(e) = server.await {
|
|
|
|
|
eprintln!("server error: {}", e);
|
|
|
|
|
}
|
2018-09-01 22:02:01 -05:00
|
|
|
}
|
|
|
|
|
}
|