Implementation of the integration between actix-web and juniper

Changes:
- Changed the place of implementation for GraphQLBatchRequest, changed it from the juniper_warp to juniper crate since it could be reused in other http integrations

Author: engylemure

Cargo.toml

@@ -11,6 +11,7 @@ members = [
   "juniper_rocket",
   "juniper_subscriptions",
   "juniper_warp",
+  "juniper_actix",
 ]
 exclude = [
   "docs/book/tests",

juniper/src/http/mod.rs

@@ -217,6 +217,125 @@ where
     }
 }
 
+/// The Expected structure of the decoded JSON document for either POST or GET requests
+/// considering Batch request.
+///
+/// You can use Serde to deserialize the incoming JSON data directly into this
+/// struct - it derives Deserialize for exactly this reason.
+///
+#[derive(Debug, serde_derive::Deserialize, PartialEq)]
+#[serde(untagged)]
+#[serde(bound = "InputValue<S>: Deserialize<'de>")]
+pub enum GraphQLBatchRequest<S = DefaultScalarValue>
+where
+    S: ScalarValue,
+{
+    /// A single operation request.
+    Single(GraphQLRequest<S>),
+    /// A batch operation request.
+    Batch(Vec<GraphQLRequest<S>>),
+}
+
+impl<S> GraphQLBatchRequest<S>
+where
+    S: ScalarValue,
+{
+    /// Execute a GraphQL batch request synchronously using the specified schema and context
+    ///
+    /// This is a simple wrapper around the `execute_sync` function exposed in GraphQLRequest.
+    pub fn execute_sync<'a, CtxT, QueryT, MutationT, SubscriptionT>(
+        &'a self,
+        root_node: &'a crate::RootNode<QueryT, MutationT, SubscriptionT, S>,
+        context: &CtxT,
+    ) -> GraphQLBatchResponse<'a, S>
+    where
+        QueryT: crate::GraphQLType<S, Context = CtxT>,
+        MutationT: crate::GraphQLType<S, Context = CtxT>,
+        SubscriptionT: crate::GraphQLType<S, Context = CtxT>,
+        SubscriptionT::TypeInfo: Send + Sync,
+        CtxT: Send + Sync,
+    {
+        match *self {
+            GraphQLBatchRequest::Single(ref request) => {
+                GraphQLBatchResponse::Single(request.execute_sync(root_node, context))
+            }
+            GraphQLBatchRequest::Batch(ref requests) => GraphQLBatchResponse::Batch(
+                requests
+                    .iter()
+                    .map(|request| request.execute_sync(root_node, context))
+                    .collect(),
+            ),
+        }
+    }
+
+    /// Executes a GraphQL request using the specified schema and context
+    ///
+    /// This is a simple wrapper around the `execute` function exposed in
+    /// GraphQLRequest
+    pub async fn execute<'a, CtxT, QueryT, MutationT, SubscriptionT>(
+        &'a self,
+        root_node: &'a crate::RootNode<'a, QueryT, MutationT, SubscriptionT, S>,
+        context: &'a CtxT,
+    ) -> GraphQLBatchResponse<'a, S>
+    where
+        QueryT: crate::GraphQLTypeAsync<S, Context = CtxT> + Send + Sync,
+        QueryT::TypeInfo: Send + Sync,
+        MutationT: crate::GraphQLTypeAsync<S, Context = CtxT> + Send + Sync,
+        MutationT::TypeInfo: Send + Sync,
+        SubscriptionT: crate::GraphQLSubscriptionType<S, Context = CtxT> + Send + Sync,
+        SubscriptionT::TypeInfo: Send + Sync,
+        CtxT: Send + Sync,
+        S: Send + Sync,
+    {
+        match *self {
+            GraphQLBatchRequest::Single(ref request) => {
+                let res = request.execute(root_node, context).await;
+                GraphQLBatchResponse::Single(res)
+            }
+            GraphQLBatchRequest::Batch(ref requests) => {
+                let futures = requests
+                    .iter()
+                    .map(|request| request.execute(root_node, context))
+                    .collect::<Vec<_>>();
+                let responses = futures::future::join_all(futures).await;
+
+                GraphQLBatchResponse::Batch(responses)
+            }
+        }
+    }
+}
+
+/// Simple wrapper around the result (GraphQLResponse) from executing a GraphQLBatchRequest
+///
+/// This struct implements Serialize, so you can simply serialize this
+/// to JSON and send it over the wire. use the `is_ok` to determine
+/// wheter to send a 200 or 400 HTTP status code.
+#[derive(serde_derive::Serialize)]
+#[serde(untagged)]
+pub enum GraphQLBatchResponse<'a, S = DefaultScalarValue>
+where
+    S: ScalarValue,
+{
+    /// Result of a single operation in a GraphQL request.
+    Single(GraphQLResponse<'a, S>),
+    /// Result of a batch operation in a GraphQL request.
+    Batch(Vec<GraphQLResponse<'a, S>>),
+}
+
+impl<'a, S> GraphQLBatchResponse<'a, S>
+where
+    S: ScalarValue,
+{
+    /// Returns if all the GraphQLResponse in this operation are ok,
+    /// you can use it to determine wheter to send a 200 or 400 HTTP status code.
+    pub fn is_ok(&self) -> bool {
+        match self {
+            GraphQLBatchResponse::Single(res) => res.is_ok(),
+            GraphQLBatchResponse::Batch(reses) => reses.iter().all(|res| res.is_ok()),
+        }
+    }
+}
+
 #[cfg(any(test, feature = "expose-test-schema"))]
 #[allow(missing_docs)]
 pub mod tests {

juniper_actix/.gitignore

@@ -0,0 +1,4 @@
+/target
+/examples/**/target/**/*
+**/*.rs.bk
+Cargo.lock

juniper_actix/CHANGELOG.md

@@ -0,0 +1,3 @@
+# master
+
+- Initial Release

juniper_actix/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "juniper_actix"
+version = "0.1.0"
+authors = ["Jordao Rosario <[email protected]>"]
+description = "Juniper GraphQL integration with Actix"
+license = "BSD-2-Clause"
+documentation = "https://docs.rs/juniper_actix"
+repository = "https://github.com/graphql-rust/juniper"
+edition = "2018"
+
+[features]
+subscriptions = ["juniper_subscriptions"]
+
+[dependencies]
+actix = "0.9.0"
+actix-rt = "1.0.0"
+actix-web = { version = "2.0.0", features = ["rustls"] }
+actix-web-actors = "2.0.0"
+futures = { version = "0.3.1", features = ["compat"] }
+juniper = { version = "0.14.2", path = "../juniper", default-features = false  }
+juniper_subscriptions = { path = "../juniper_subscriptions", optional = true}
+tokio = { version = "0.2", features = ["time"] }
+serde_json = "1.0.24"
+serde_derive = "1.0.75"
+failure = "0.1.7"
+serde = "1.0.75"
+
+[dev-dependencies]
+juniper = { version = "0.14.2", path = "../juniper", features = ["expose-test-schema", "serde_json"] }
+env_logger = "0.5.11"
+log = "0.4.3"
+percent-encoding = "1.0"
+tokio = { version = "0.2", features = ["rt-core", "macros", "blocking"] }
+actix-cors = "0.2.0"
+actix-identity = "0.2.0"
+bytes = "0.5.4"
+
+[[example]]
+name="actix_subscriptions"
+required-features=["subscriptions"]

juniper_actix/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, Jordao Rosario
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

juniper_actix/README.md

@@ -0,0 +1,34 @@
+# juniper_actix
+
+This repository contains the [actix][actix] web server integration for
+[Juniper][Juniper], a [GraphQL][GraphQL] implementation for Rust, its inspired and some parts are copied from  [juniper_warp][juniper_warp].
+
+## Documentation
+
+For documentation, including guides and examples, check out [Juniper][Juniper].
+
+A basic usage example can also be found in the [API documentation][documentation].
+
+## Examples
+
+Check [examples/actix_server][example] for example code of a working actix
+server with GraphQL handlers.
+
+## Links
+
+* [Juniper][Juniper]
+* [API Reference][documentation]
+* [actix][actix]
+
+## License
+
+This project is under the BSD-2 license.
+
+Check the LICENSE file for details.
+
+[actix]: https://github.com/actix/actix-web
+[Juniper]: https://github.com/graphql-rust/juniper
+[GraphQL]: http://graphql.org
+[documentation]: https://docs.rs/juniper_actix
+[example]: https://github.com/graphql-rust/juniper/blob/master/juniper_actix/examples/actix_server.rs
+[juniper_warp]:https://docs.rs/juniper_warp

juniper_actix/examples/actix_server.rs

@@ -0,0 +1,73 @@
+#![deny(warnings)]
+
+extern crate log;
+use actix_cors::Cors;
+use actix_web::{middleware, web, App, Error, HttpResponse, HttpServer};
+use juniper::{
+    http::{GraphQLBatchRequest, GraphQLRequest},
+    tests::{model::Database, schema::Query},
+    DefaultScalarValue, EmptyMutation, EmptySubscription, RootNode,
+};
+use juniper_actix::{
+    get_graphql_handler, graphiql_handler as gqli_handler, playground_handler as play_handler,
+    post_graphql_handler,
+};
+
+type Schema = RootNode<'static, Query, EmptyMutation<Database>, EmptySubscription<Database>>;
+
+fn schema() -> Schema {
+    Schema::new(
+        Query,
+        EmptyMutation::<Database>::new(),
+        EmptySubscription::<Database>::new(),
+    )
+}
+
+async fn graphiql_handler() -> Result<HttpResponse, Error> {
+    gqli_handler("/").await
+}
+async fn playground_handler() -> Result<HttpResponse, Error> {
+    play_handler("/", None).await
+}
+async fn graphql(
+    req: web::Json<GraphQLBatchRequest<DefaultScalarValue>>,
+    schema: web::Data<Schema>,
+) -> Result<HttpResponse, Error> {
+    let context = Database::new();
+    post_graphql_handler(&schema, &context, req).await
+}
+
+async fn graphql_get(
+    req: web::Query<GraphQLRequest<DefaultScalarValue>>,
+    schema: web::Data<Schema>,
+) -> Result<HttpResponse, Error> {
+    let context = Database::new();
+    get_graphql_handler(&schema, &context, req).await
+}
+
+#[actix_rt::main]
+async fn main() -> std::io::Result<()> {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    let server = HttpServer::new(move || {
+        App::new()
+            .data(schema())
+            .wrap(middleware::Compress::default())
+            .wrap(middleware::Logger::default())
+            .wrap(
+                Cors::new()
+                    .allowed_methods(vec!["POST", "GET"])
+                    .supports_credentials()
+                    .max_age(3600)
+                    .finish(),
+            )
+            .service(
+                web::resource("/")
+                    .route(web::post().to(graphql))
+                    .route(web::get().to(graphql_get)),
+            )
+            .service(web::resource("/playground").route(web::get().to(playground_handler)))
+            .service(web::resource("/graphiql").route(web::get().to(graphiql_handler)))
+    });
+    server.bind("127.0.0.1:8080").unwrap().run().await
+}