#![warn(missing_docs)]
#![allow(clippy::type_complexity)]
#![allow(clippy::needless_doctest_main)]
#![forbid(unsafe_code)]
use async_graphql::http::{multipart_stream, GQLRequest, GQLResponse, StreamBody};
use async_graphql::{
IntoQueryBuilder, IntoQueryBuilderOpts, ObjectType, QueryBuilder, QueryResponse, Schema,
StreamResponse, SubscriptionType,
};
use async_trait::async_trait;
use futures::channel::mpsc;
use futures::io::BufReader;
use futures::{SinkExt, StreamExt};
use std::str::FromStr;
use tide::{
http::{headers, Method},
Body, Request, Response, Status, StatusCode,
};
pub async fn graphql<Query, Mutation, Subscription, TideState, F>(
req: Request<TideState>,
schema: Schema<Query, Mutation, Subscription>,
query_builder_configuration: F,
) -> tide::Result<Response>
where
Query: ObjectType + Send + Sync + 'static,
Mutation: ObjectType + Send + Sync + 'static,
Subscription: SubscriptionType + Send + Sync + 'static,
TideState: Send + Sync + 'static,
F: Fn(QueryBuilder) -> QueryBuilder + Send,
{
graphql_opts(req, schema, query_builder_configuration, Default::default()).await
}
pub async fn graphql_opts<Query, Mutation, Subscription, TideState, F>(
req: Request<TideState>,
schema: Schema<Query, Mutation, Subscription>,
query_builder_configuration: F,
opts: IntoQueryBuilderOpts,
) -> tide::Result<Response>
where
Query: ObjectType + Send + Sync + 'static,
Mutation: ObjectType + Send + Sync + 'static,
Subscription: SubscriptionType + Send + Sync + 'static,
TideState: Send + Sync + 'static,
F: Fn(QueryBuilder) -> QueryBuilder + Send,
{
let query_builder = req.body_graphql_opts(opts).await?;
Response::new(StatusCode::Ok).body_graphql(
query_builder_configuration(query_builder)
.execute(&schema)
.await,
)
}
#[async_trait]
pub trait RequestExt<State: Send + Sync + 'static>: Sized {
async fn body_graphql(self) -> tide::Result<QueryBuilder> {
self.body_graphql_opts(Default::default()).await
}
async fn body_graphql_opts(self, opts: IntoQueryBuilderOpts) -> tide::Result<QueryBuilder>;
}
#[async_trait]
impl<State: Send + Sync + 'static> RequestExt<State> for Request<State> {
async fn body_graphql_opts(self, opts: IntoQueryBuilderOpts) -> tide::Result<QueryBuilder> {
if self.method() == Method::Get {
let gql_request: GQLRequest = self.query::<GQLRequest>()?;
let builder = gql_request
.into_query_builder_opts(&opts)
.await
.status(StatusCode::BadRequest)?;
Ok(builder)
} else {
let content_type = self
.header(&headers::CONTENT_TYPE)
.and_then(|values| values.get(0).map(|value| value.to_string()));
Ok((content_type, self).into_query_builder_opts(&opts).await?)
}
}
}
pub trait ResponseExt: Sized {
fn body_graphql(self, res: async_graphql::Result<QueryResponse>) -> tide::Result<Self>;
fn body_graphql_stream(self, res: StreamResponse) -> tide::Result<Self>;
}
impl ResponseExt for Response {
fn body_graphql(self, res: async_graphql::Result<QueryResponse>) -> tide::Result<Self> {
let mut resp = add_cache_control(self, &res);
resp.set_body(Body::from_json(&GQLResponse(res))?);
Ok(resp)
}
fn body_graphql_stream(mut self, res: StreamResponse) -> tide::Result<Self> {
match res {
StreamResponse::Single(res) => self.body_graphql(res),
StreamResponse::Stream(stream) => {
let mut stream =
Box::pin(multipart_stream(stream).map(Result::Ok::<_, std::io::Error>));
let (mut tx, rx) = mpsc::channel(0);
async_std::task::spawn(async move {
while let Some(item) = stream.next().await {
if tx.send(item).await.is_err() {
return;
}
}
});
self.set_body(Body::from_reader(BufReader::new(StreamBody::new(rx)), None));
self.insert_header(tide::http::headers::CONTENT_TYPE, "multipart/mixed");
Ok(self)
}
}
}
}
fn add_cache_control(
mut http_resp: Response,
resp: &async_graphql::Result<QueryResponse>,
) -> Response {
if let Ok(QueryResponse { cache_control, .. }) = resp {
if let Some(cache_control) = cache_control.value() {
if let Ok(header) = tide::http::headers::HeaderName::from_str("cache-control") {
http_resp.insert_header(header, cache_control);
return http_resp;
}
}
}
http_resp
}