Big improvements to tide integration
This commit is contained in:
parent
79869b5032
commit
7f35fbca4c
|
@ -1,4 +1,7 @@
|
|||
//! Async-graphql integration with Tide
|
||||
//!
|
||||
//! # Examples
|
||||
//! *[Full Example](<https://github.com/async-graphql/examples/blob/master/tide/starwars/src/main.rs>)*
|
||||
|
||||
#![warn(missing_docs)]
|
||||
#![allow(clippy::type_complexity)]
|
||||
|
@ -8,135 +11,100 @@
|
|||
use async_graphql::http::MultipartOptions;
|
||||
use async_graphql::{resolver_utils::ObjectType, Schema, SubscriptionType};
|
||||
use async_trait::async_trait;
|
||||
use std::str::FromStr;
|
||||
use tide::{
|
||||
http::{headers, Method},
|
||||
http::{
|
||||
headers::{self, HeaderValue},
|
||||
Method,
|
||||
},
|
||||
Body, Request, Response, StatusCode,
|
||||
};
|
||||
|
||||
/// GraphQL request handler
|
||||
///
|
||||
///
|
||||
/// # Examples
|
||||
/// *[Full Example](<https://github.com/async-graphql/examples/blob/master/tide/starwars/src/main.rs>)*
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_graphql::*;
|
||||
/// use async_std::task;
|
||||
/// use tide::Request;
|
||||
///
|
||||
/// struct QueryRoot;
|
||||
/// #[Object]
|
||||
/// impl QueryRoot {
|
||||
/// #[field(desc = "Returns the sum of a and b")]
|
||||
/// async fn add(&self, a: i32, b: i32) -> i32 {
|
||||
/// a + b
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// fn main() -> std::result::Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
||||
/// task::block_on(async {
|
||||
/// let mut app = tide::new();
|
||||
/// app.at("/").post(|req: Request<()>| async move {
|
||||
/// let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription).finish();
|
||||
/// async_graphql_tide::graphql(req, schema, |query_builder| query_builder).await
|
||||
/// });
|
||||
/// app.listen("0.0.0.0:8000").await?;
|
||||
///
|
||||
/// Ok(())
|
||||
/// })
|
||||
/// }
|
||||
/// ```
|
||||
pub async fn graphql<Query, Mutation, Subscription, TideState, F>(
|
||||
req: Request<TideState>,
|
||||
/// Create a new GraphQL endpoint with the schema and default multipart options.
|
||||
pub fn endpoint<Query, Mutation, Subscription>(
|
||||
schema: Schema<Query, Mutation, Subscription>,
|
||||
configuration: F,
|
||||
) -> tide::Result<Response>
|
||||
where
|
||||
Query: ObjectType + Send + Sync + 'static,
|
||||
Mutation: ObjectType + Send + Sync + 'static,
|
||||
Subscription: SubscriptionType + Send + Sync + 'static,
|
||||
TideState: Clone + Send + Sync + 'static,
|
||||
F: FnOnce(async_graphql::Request) -> async_graphql::Request + Send,
|
||||
{
|
||||
graphql_opts(req, schema, configuration, Default::default()).await
|
||||
) -> Endpoint<Query, Mutation, Subscription> {
|
||||
endpoint_options(schema, MultipartOptions::default())
|
||||
}
|
||||
|
||||
/// Similar to graphql, but you can set the options `async_graphql::MultipartOptions`.
|
||||
pub async fn graphql_opts<Query, Mutation, Subscription, TideState, F>(
|
||||
req: Request<TideState>,
|
||||
/// Create a new GraphQL endpoint with the schema and custom multipart options.
|
||||
pub fn endpoint_options<Query, Mutation, Subscription>(
|
||||
schema: Schema<Query, Mutation, Subscription>,
|
||||
configuration: F,
|
||||
opts: MultipartOptions,
|
||||
) -> tide::Result<Response>
|
||||
where
|
||||
Query: ObjectType + Send + Sync + 'static,
|
||||
Mutation: ObjectType + Send + Sync + 'static,
|
||||
Subscription: SubscriptionType + Send + Sync + 'static,
|
||||
TideState: Clone + Send + Sync + 'static,
|
||||
F: FnOnce(async_graphql::Request) -> async_graphql::Request + Send,
|
||||
{
|
||||
let request = req.body_graphql_opts(opts).await?;
|
||||
Response::new(StatusCode::Ok).body_graphql(schema.execute(configuration(request)).await)
|
||||
) -> Endpoint<Query, Mutation, Subscription> {
|
||||
Endpoint { schema, opts }
|
||||
}
|
||||
|
||||
/// Tide request extension
|
||||
///
|
||||
#[async_trait]
|
||||
pub trait RequestExt<State: Clone + Send + Sync + 'static>: Sized {
|
||||
/// Convert a query to `async_graphql::Request`.
|
||||
async fn body_graphql(self) -> tide::Result<async_graphql::Request> {
|
||||
self.body_graphql_opts(Default::default()).await
|
||||
/// A GraphQL endpoint.
|
||||
pub struct Endpoint<Query, Mutation, Subscription> {
|
||||
/// The schema of the endpoint.
|
||||
pub schema: Schema<Query, Mutation, Subscription>,
|
||||
/// The multipart options of the endpoint.
|
||||
pub opts: MultipartOptions,
|
||||
}
|
||||
|
||||
// Manual impl to remove bounds on generics
|
||||
impl<Query, Mutation, Subscription> Clone for Endpoint<Query, Mutation, Subscription> {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
schema: self.schema.clone(),
|
||||
opts: self.opts,
|
||||
}
|
||||
}
|
||||
|
||||
/// Similar to `RequestExt::body_graphql`, but you can set the options `async_graphql::MultipartOptions`.
|
||||
async fn body_graphql_opts(
|
||||
self,
|
||||
opts: MultipartOptions,
|
||||
) -> tide::Result<async_graphql::Request>;
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl<State: Clone + Send + Sync + 'static> RequestExt<State> for Request<State> {
|
||||
async fn body_graphql_opts(
|
||||
self,
|
||||
impl<Query, Mutation, Subscription, TideState> tide::Endpoint<TideState>
|
||||
for Endpoint<Query, Mutation, Subscription>
|
||||
where
|
||||
Query: ObjectType + Send + Sync + 'static,
|
||||
Mutation: ObjectType + Send + Sync + 'static,
|
||||
Subscription: SubscriptionType + Send + Sync + 'static,
|
||||
TideState: Clone + Send + Sync + 'static,
|
||||
{
|
||||
async fn call(&self, request: Request<TideState>) -> tide::Result {
|
||||
respond(
|
||||
self.schema
|
||||
.execute(receive_request_opts(request, self.opts).await?)
|
||||
.await,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a Tide request to a GraphQL request.
|
||||
pub async fn receive_request<State: Clone + Send + Sync + 'static>(
|
||||
request: Request<State>,
|
||||
) -> tide::Result<async_graphql::Request> {
|
||||
receive_request_opts(request, Default::default()).await
|
||||
}
|
||||
|
||||
/// Convert a Tide request to a GraphQL request with options on how to receive multipart.
|
||||
pub async fn receive_request_opts<State: Clone + Send + Sync + 'static>(
|
||||
mut request: Request<State>,
|
||||
opts: MultipartOptions,
|
||||
) -> tide::Result<async_graphql::Request> {
|
||||
if self.method() == Method::Get {
|
||||
Ok(self.query::<async_graphql::Request>()?)
|
||||
) -> tide::Result<async_graphql::Request> {
|
||||
if request.method() == Method::Get {
|
||||
request.query()
|
||||
} else {
|
||||
let content_type = self
|
||||
.header(&headers::CONTENT_TYPE)
|
||||
.and_then(|values| values.get(0).map(|value| value.to_string()));
|
||||
async_graphql::http::receive_body(content_type, self, opts)
|
||||
let body = request.take_body();
|
||||
let content_type = request
|
||||
.header(headers::CONTENT_TYPE)
|
||||
.and_then(|values| values.get(0))
|
||||
.map(HeaderValue::as_str);
|
||||
|
||||
async_graphql::http::receive_body(content_type, body, opts)
|
||||
.await
|
||||
.map_err(|err| tide::Error::new(StatusCode::BadRequest, err))
|
||||
}
|
||||
.map_err(|e| tide::Error::new(StatusCode::BadRequest, e))
|
||||
}
|
||||
}
|
||||
|
||||
/// Tide response extension
|
||||
///
|
||||
pub trait ResponseExt: Sized {
|
||||
/// Set body as the result of a GraphQL query.
|
||||
fn body_graphql(self, res: async_graphql::Response) -> tide::Result<Self>;
|
||||
}
|
||||
|
||||
impl ResponseExt for Response {
|
||||
fn body_graphql(self, res: async_graphql::Response) -> tide::Result<Self> {
|
||||
let mut resp = add_cache_control(self, &res);
|
||||
resp.set_body(Body::from_json(&res)?);
|
||||
Ok(resp)
|
||||
}
|
||||
}
|
||||
|
||||
fn add_cache_control(mut http_resp: Response, resp: &async_graphql::Response) -> Response {
|
||||
if resp.is_ok() {
|
||||
if let Some(cache_control) = resp.cache_control.value() {
|
||||
if let Ok(header) = tide::http::headers::HeaderName::from_str("cache-control") {
|
||||
http_resp.insert_header(header, cache_control);
|
||||
}
|
||||
}
|
||||
}
|
||||
http_resp
|
||||
/// Convert a GraphQL response to a Tide response.
|
||||
pub fn respond(gql: async_graphql::Response) -> tide::Result {
|
||||
let mut response = Response::new(StatusCode::Ok);
|
||||
if gql.is_ok() {
|
||||
if let Some(cache_control) = gql.cache_control.value() {
|
||||
response.insert_header(headers::CACHE_CONTROL, cache_control);
|
||||
}
|
||||
}
|
||||
response.set_body(Body::from_json(&gql)?);
|
||||
Ok(response)
|
||||
}
|
||||
|
|
|
@ -14,9 +14,6 @@ fn quickstart() -> Result<()> {
|
|||
let listen_addr = test_utils::find_listen_addr().await;
|
||||
|
||||
let server = Task::<Result<()>>::spawn(async move {
|
||||
use async_graphql_tide::{RequestExt, ResponseExt};
|
||||
use tide::{http::StatusCode, Request, Response};
|
||||
|
||||
struct QueryRoot;
|
||||
#[Object]
|
||||
impl QueryRoot {
|
||||
|
@ -26,14 +23,11 @@ fn quickstart() -> Result<()> {
|
|||
}
|
||||
}
|
||||
|
||||
async fn graphql(req: Request<()>) -> tide::Result<Response> {
|
||||
let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription).finish();
|
||||
let request = req.body_graphql().await?;
|
||||
Ok(Response::new(StatusCode::Ok).body_graphql(schema.execute(request).await)?)
|
||||
}
|
||||
|
||||
let mut app = tide::new();
|
||||
app.at("/").post(graphql).get(graphql);
|
||||
let endpoint = async_graphql_tide::endpoint(schema);
|
||||
app.at("/").post(endpoint.clone()).get(endpoint);
|
||||
app.listen(listen_addr).await?;
|
||||
|
||||
Ok(())
|
||||
|
@ -108,28 +102,23 @@ fn hello() -> Result<()> {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct AppState {
|
||||
schema: Schema<QueryRoot, EmptyMutation, EmptySubscription>,
|
||||
}
|
||||
let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription).finish();
|
||||
|
||||
let app_state = AppState { schema };
|
||||
let mut app = tide::with_state(app_state);
|
||||
let mut app = tide::new();
|
||||
|
||||
app.at("/").post(|req: Request<AppState>| async move {
|
||||
let schema = req.state().schema.clone();
|
||||
let name = &req
|
||||
app.at("/").post(move |req: Request<()>| {
|
||||
let schema = schema.clone();
|
||||
async move {
|
||||
let name = req
|
||||
.header("name")
|
||||
.and_then(|values| values.get(0).map(|value| value.to_string()));
|
||||
|
||||
async_graphql_tide::graphql(req, schema, |mut query_builder| {
|
||||
.and_then(|values| values.get(0))
|
||||
.map(ToString::to_string);
|
||||
let mut req = async_graphql_tide::receive_request(req).await?;
|
||||
if let Some(name) = name {
|
||||
query_builder = query_builder.data(Hello(name.to_string()))
|
||||
req = req.data(Hello(name));
|
||||
}
|
||||
async_graphql_tide::respond(schema.execute(req).await)
|
||||
}
|
||||
query_builder
|
||||
})
|
||||
.await
|
||||
});
|
||||
app.listen(listen_addr).await?;
|
||||
|
||||
|
@ -191,8 +180,6 @@ fn upload() -> Result<()> {
|
|||
let listen_addr = test_utils::find_listen_addr().await;
|
||||
|
||||
let server = Task::<Result<()>>::spawn(async move {
|
||||
use tide::Request;
|
||||
|
||||
struct QueryRoot;
|
||||
#[Object]
|
||||
impl QueryRoot {}
|
||||
|
@ -223,11 +210,10 @@ fn upload() -> Result<()> {
|
|||
}
|
||||
}
|
||||
|
||||
let mut app = tide::new();
|
||||
app.at("/").post(|req: Request<()>| async move {
|
||||
let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription).finish();
|
||||
async_graphql_tide::graphql(req, schema, |query_builder| query_builder).await
|
||||
});
|
||||
|
||||
let mut app = tide::new();
|
||||
app.at("/").post(async_graphql_tide::endpoint(schema));
|
||||
app.listen(listen_addr).await?;
|
||||
|
||||
Ok(())
|
||||
|
|
|
@ -10,7 +10,7 @@ use std::pin::Pin;
|
|||
use std::task::{Context, Poll};
|
||||
|
||||
/// Options for `receive_multipart`.
|
||||
#[derive(Default, Clone)]
|
||||
#[derive(Default, Clone, Copy)]
|
||||
#[non_exhaustive]
|
||||
#[cfg_attr(feature = "nightly", doc(cfg(feature = "multipart")))]
|
||||
pub struct MultipartOptions {
|
||||
|
|
Loading…
Reference in New Issue
Block a user