mbp2 0.3.1

A common-utility library for federated projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

#[cfg(feature = "async-gql")]
mod __async_gql {
   // TODO: Implement Async-graphql Actix integration.
}

#[cfg(feature = "juniper-gql")]
mod __juniper {
   /// A handler for GraphQL queries, mutations, and subscriptions.
   pub async fn GqlHandler<QueryT, MutationT, SubscriptionT, CtxT, S>(
      schema: &juniper::RootNode<'static, QueryT, MutationT, SubscriptionT, S>,
      context: &CtxT,
      req: HttpRequest,
      payload: Payload,
   ) -> Result<HttpResponse, Error>
   where
      QueryT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      QueryT::TypeInfo: Sync,
      MutationT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      MutationT::TypeInfo: Sync,
      SubscriptionT: juniper::GraphQLSubscriptionType<S, Context = CtxT>,
      SubscriptionT::TypeInfo: Sync,
      CtxT: Sync,
      S: ScalarValue + Send + Sync,
   {
      match *req.method() {
         Method::POST => PostGqlHandler(schema, context, req, payload).await,
         Method::GET => GetGqlHandler(schema, context, req).await,
         _ => Err(actix_web::error::UrlGenerationError::ResourceNotFound.into()),
      }
   }

   /// GraphQL handler specialised for HTTP GET requests.
   pub async fn GetGqlHandler<QueryT, MutationT, SubscriptionT, CtxT, S>(
      schema: &juniper::RootNode<'static, QueryT, MutationT, SubscriptionT, S>,
      context: &CtxT,
      req: HttpRequest,
   ) -> Result<HttpResponse, Error>
   where
      QueryT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      QueryT::TypeInfo: Sync,
      MutationT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      MutationT::TypeInfo: Sync,
      SubscriptionT: juniper::GraphQLSubscriptionType<S, Context = CtxT>,
      SubscriptionT::TypeInfo: Sync,
      CtxT: Sync,
      S: ScalarValue + Send + Sync,
   {
      let getReq = web::Query::<GetGqlRequest>::from_query(req.query_string())?;
      let req = GraphQLRequest::from(getReq.into_inner());
      let gqlResponse = req.execute(schema, context).await;
      let bodyResponse = serde_json::to_string(&gqlResponse)?;
      let mut response = match gqlResponse.is_ok() {
         true => HttpResponse::Ok(),
         false => HttpResponse::BadRequest(),
      };

      Ok(response.content_type("application/json").body(bodyResponse))
   }

   /// GraphQL handler specialised for HTTP POST requests.
   pub async fn PostGqlHandler<QueryT, MutationT, SubscriptionT, CtxT, S>(
      schema: &juniper::RootNode<'static, QueryT, MutationT, SubscriptionT, S>,
      context: &CtxT,
      req: HttpRequest,
      payload: Payload,
   ) -> Result<HttpResponse, Error>
   where
      QueryT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      QueryT::TypeInfo: Sync,
      MutationT: juniper::GraphQLTypeAsync<S, Context = CtxT>,
      MutationT::TypeInfo: Sync,
      SubscriptionT: juniper::GraphQLSubscriptionType<S, Context = CtxT>,
      SubscriptionT::TypeInfo: Sync,
      CtxT: Sync,
      S: ScalarValue + Send + Sync,
   {
      let req = match req.content_type() {
         "application/json" => {
            let body = String::from_request(&req, &mut payload.into_inner()).await?;
            serde_json::from_str::<GraphQLBatchRequest<S>>(&body).map_err(JsonPayloadError::Deserialize)
         }
         "application/graphql" => {
            let body = String::from_request(&req, &mut payload.into_inner()).await?;
            Ok(GraphQLBatchRequest::Single(GraphQLRequest::new(body, None, None)))
         }
         _ => Err(JsonPayloadError::ContentType),
      }?;
      let gqlBatchResponse = req.execute(schema, context).await;
      let gqlResponse = serde_json::to_string(&gqlBatchResponse)?;
      let mut response = match gqlBatchResponse.is_ok() {
         true => HttpResponse::Ok(),
         false => HttpResponse::BadRequest(),
      };
      Ok(response.content_type("application/json").body(gqlResponse))
   }

   use {
      crate::api::*,
      actix_web::{
         error::JsonPayloadError,
         http::Method,
         web::{self, Payload},
         Error,
         FromRequest, HttpRequest,
         HttpResponse, HttpMessage,
      },
      juniper::{http::{GraphQLRequest, GraphQLBatchRequest}, ScalarValue},
   };
}

#[cfg(feature = "async-gql")]
pub use self::__async_gql::*;
#[cfg(feature = "juniper-gql")]
pub use self::__juniper::*;