#![warn(missing_docs)]
#![allow(clippy::type_complexity)]
#![allow(clippy::needless_doctest_main)]
#![forbid(unsafe_code)]
use async_graphql::http::{GQLRequest, MultipartOptions};
use async_graphql::{ObjectType, Schema, SubscriptionType};
use async_trait::async_trait;
use std::str::FromStr;
use tide::{
http::{headers, Method},
Body, Request, Response, StatusCode,
};
pub async fn graphql<Query, Mutation, Subscription, TideState, F>(
req: Request<TideState>,
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
}
pub async fn graphql_opts<Query, Mutation, Subscription, TideState, F>(
req: Request<TideState>,
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)
}
#[async_trait]
pub trait RequestExt<State: Clone + Send + Sync + 'static>: Sized {
async fn body_graphql(self) -> tide::Result<async_graphql::Request> {
self.body_graphql_opts(Default::default()).await
}
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,
opts: MultipartOptions,
) -> tide::Result<async_graphql::Request> {
if self.method() == Method::Get {
Ok(self.query::<GQLRequest>()?.into())
} 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)
.await
.map_err(|err| tide::Error::new(StatusCode::BadRequest, err))
}
}
}
pub trait ResponseExt: Sized {
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
}