update async-graphql example

graphql/async-graphql/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "async-graphql-demo"
+version = "1.0.0"
+edition = "2021"
+
+[dependencies]
+actix-web = "4.0.0-rc.3"
+actix-web-lab = "0.10"
+actix-cors = "0.6.0-beta.10"
+
+async-graphql = "3"
+async-graphql-actix-web = "3"
+
+env_logger = "0.9"
+log = "0.4"
+slab = "0.4.2"

graphql/async-graphql/README.md

@@ -0,0 +1,38 @@
+## GraphQL using `async-graphql`
+
+> Getting started using [async-graphql](https://github.com/async-graphql/async-graphql) with Actix Web.
+
+## Usage
+
+```bash
+cd graphql/graphql-demo
+cargo run
+```
+
+## Endpoints
+
+```
+GET/POST  http://localhost:8080/graphql   GraphQL endpoint
+GET       http://localhost:8080/graphiql  GraphQL playground UI
+```
+
+## Query Examples
+
+```graphql
+{
+  humans {
+    edges {
+      node {
+        id
+        name
+        friends {
+          id
+          name
+        }
+        appearsIn
+        homePlanet
+      }
+    }
+  }
+}
+```

graphql/async-graphql/src/main.rs

@@ -0,0 +1,53 @@
+use actix_cors::Cors;
+use actix_web::{get, middleware::Logger, route, web, App, HttpServer, Responder};
+use actix_web_lab::respond::Html;
+use async_graphql::{
+    http::{playground_source, GraphQLPlaygroundConfig},
+    EmptyMutation, EmptySubscription, Schema,
+};
+use async_graphql_actix_web::{GraphQLRequest, GraphQLResponse};
+
+mod star_wars;
+use self::star_wars::{QueryRoot, StarWars, StarWarsSchema};
+
+/// GraphQL endpoint
+#[route("/graphql", method = "GET", method = "POST")]
+async fn graphql(
+    schema: web::Data<StarWarsSchema>,
+    req: GraphQLRequest,
+) -> GraphQLResponse {
+    schema.execute(req.into_inner()).await.into()
+}
+
+/// GraphiQL playground UI
+#[get("/graphiql")]
+async fn graphql_playground() -> impl Responder {
+    Html(playground_source(
+        GraphQLPlaygroundConfig::new("/graphql").subscription_endpoint("/graphql"),
+    ))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription)
+        .data(StarWars::new())
+        .finish();
+
+    log::info!("starting HTTP server on port 8080");
+    log::info!("GraphiQL playground: http://localhost:8080/graphiql");
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(web::Data::new(schema.clone()))
+            .service(graphql)
+            .service(graphql_playground)
+            .wrap(Cors::permissive())
+            .wrap(Logger::default())
+    })
+    .workers(2)
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}

graphql/async-graphql/src/star_wars/mod.rs

@@ -0,0 +1,140 @@
+use std::collections::HashMap;
+
+use async_graphql::{EmptyMutation, EmptySubscription, Schema};
+use model::Episode;
+use slab::Slab;
+
+pub type StarWarsSchema = Schema<QueryRoot, EmptyMutation, EmptySubscription>;
+
+mod model;
+pub use self::model::QueryRoot;
+
+pub struct StarWarsChar {
+    id: &'static str,
+    name: &'static str,
+    friends: Vec<usize>,
+    appears_in: Vec<Episode>,
+    home_planet: Option<&'static str>,
+    primary_function: Option<&'static str>,
+}
+
+pub struct StarWars {
+    luke: usize,
+    artoo: usize,
+    chars: Slab<StarWarsChar>,
+    human_data: HashMap<&'static str, usize>,
+    droid_data: HashMap<&'static str, usize>,
+}
+
+impl StarWars {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        let mut chars = Slab::new();
+
+        let luke = chars.insert(StarWarsChar {
+            id: "1000",
+            name: "Luke Skywalker",
+            friends: vec![],
+            appears_in: vec![],
+            home_planet: Some("Tatooine"),
+            primary_function: None,
+        });
+
+        let vader = chars.insert(StarWarsChar {
+            id: "1001",
+            name: "Luke Skywalker",
+            friends: vec![],
+            appears_in: vec![],
+            home_planet: Some("Tatooine"),
+            primary_function: None,
+        });
+
+        let han = chars.insert(StarWarsChar {
+            id: "1002",
+            name: "Han Solo",
+            friends: vec![],
+            appears_in: vec![Episode::Empire, Episode::NewHope, Episode::Jedi],
+            home_planet: None,
+            primary_function: None,
+        });
+
+        let leia = chars.insert(StarWarsChar {
+            id: "1003",
+            name: "Leia Organa",
+            friends: vec![],
+            appears_in: vec![Episode::Empire, Episode::NewHope, Episode::Jedi],
+            home_planet: Some("Alderaa"),
+            primary_function: None,
+        });
+
+        let tarkin = chars.insert(StarWarsChar {
+            id: "1004",
+            name: "Wilhuff Tarkin",
+            friends: vec![],
+            appears_in: vec![Episode::Empire, Episode::NewHope, Episode::Jedi],
+            home_planet: None,
+            primary_function: None,
+        });
+
+        let threepio = chars.insert(StarWarsChar {
+            id: "2000",
+            name: "C-3PO",
+            friends: vec![],
+            appears_in: vec![Episode::Empire, Episode::NewHope, Episode::Jedi],
+            home_planet: None,
+            primary_function: Some("Protocol"),
+        });
+
+        let artoo = chars.insert(StarWarsChar {
+            id: "2001",
+            name: "R2-D2",
+            friends: vec![],
+            appears_in: vec![Episode::Empire, Episode::NewHope, Episode::Jedi],
+            home_planet: None,
+            primary_function: Some("Astromech"),
+        });
+
+        chars[luke].friends = vec![han, leia, threepio, artoo];
+        chars[vader].friends = vec![tarkin];
+        chars[han].friends = vec![luke, leia, artoo];
+        chars[leia].friends = vec![luke, han, threepio, artoo];
+        chars[tarkin].friends = vec![vader];
+        chars[threepio].friends = vec![luke, han, leia, artoo];
+        chars[artoo].friends = vec![luke, han, leia];
+
+        let mut human_data = HashMap::new();
+        human_data.insert("1000", luke);
+        human_data.insert("1001", vader);
+        human_data.insert("1002", han);
+        human_data.insert("1003", leia);
+        human_data.insert("1004", tarkin);
+
+        let mut droid_data = HashMap::new();
+        droid_data.insert("2000", threepio);
+        droid_data.insert("2001", artoo);
+
+        Self {
+            luke,
+            artoo,
+            chars,
+            human_data,
+            droid_data,
+        }
+    }
+
+    pub fn human(&self, id: &str) -> Option<usize> {
+        self.human_data.get(id).cloned()
+    }
+
+    pub fn droid(&self, id: &str) -> Option<usize> {
+        self.droid_data.get(id).cloned()
+    }
+
+    pub fn humans(&self) -> Vec<usize> {
+        self.human_data.values().cloned().collect()
+    }
+
+    pub fn droids(&self) -> Vec<usize> {
+        self.droid_data.values().cloned().collect()
+    }
+}

graphql/async-graphql/src/star_wars/model.rs

@@ -0,0 +1,227 @@
+use async_graphql::connection::{query, Connection, Edge, EmptyFields};
+use async_graphql::{Context, Enum, FieldResult, Interface, Object};
+
+use super::StarWars;
+
+/// One of the films in the Star Wars Trilogy
+#[derive(Enum, Copy, Clone, Eq, PartialEq)]
+pub enum Episode {
+    /// Released in 1977.
+    NewHope,
+
+    /// Released in 1980.
+    Empire,
+
+    /// Released in 1983.
+    Jedi,
+}
+
+pub struct Human(usize);
+
+/// A humanoid creature in the Star Wars universe.
+#[Object]
+impl Human {
+    /// The id of the human.
+    async fn id(&self, ctx: &Context<'_>) -> &str {
+        ctx.data_unchecked::<StarWars>().chars[self.0].id
+    }
+
+    /// The name of the human.
+    async fn name(&self, ctx: &Context<'_>) -> &str {
+        ctx.data_unchecked::<StarWars>().chars[self.0].name
+    }
+
+    /// The friends of the human, or an empty list if they have none.
+    async fn friends(&self, ctx: &Context<'_>) -> Vec<Character> {
+        ctx.data_unchecked::<StarWars>().chars[self.0]
+            .friends
+            .iter()
+            .map(|id| Human(*id).into())
+            .collect()
+    }
+
+    /// Which movies they appear in.
+    async fn appears_in<'a>(&self, ctx: &'a Context<'_>) -> &'a [Episode] {
+        &ctx.data_unchecked::<StarWars>().chars[self.0].appears_in
+    }
+
+    /// The home planet of the human, or null if unknown.
+    async fn home_planet<'a>(&self, ctx: &'a Context<'_>) -> &'a Option<&'a str> {
+        &ctx.data_unchecked::<StarWars>().chars[self.0].home_planet
+    }
+}
+
+pub struct Droid(usize);
+
+/// A mechanical creature in the Star Wars universe.
+#[Object]
+impl Droid {
+    /// The id of the droid.
+    async fn id(&self, ctx: &Context<'_>) -> &str {
+        ctx.data_unchecked::<StarWars>().chars[self.0].id
+    }
+
+    /// The name of the droid.
+    async fn name(&self, ctx: &Context<'_>) -> &str {
+        ctx.data_unchecked::<StarWars>().chars[self.0].name
+    }
+
+    /// The friends of the droid, or an empty list if they have none.
+    async fn friends(&self, ctx: &Context<'_>) -> Vec<Character> {
+        ctx.data_unchecked::<StarWars>().chars[self.0]
+            .friends
+            .iter()
+            .map(|id| Droid(*id).into())
+            .collect()
+    }
+
+    /// Which movies they appear in.
+    async fn appears_in<'a>(&self, ctx: &'a Context<'_>) -> &'a [Episode] {
+        &ctx.data_unchecked::<StarWars>().chars[self.0].appears_in
+    }
+
+    /// The primary function of the droid.
+    async fn primary_function<'a>(&self, ctx: &'a Context<'_>) -> &'a Option<&'a str> {
+        &ctx.data_unchecked::<StarWars>().chars[self.0].primary_function
+    }
+}
+
+pub struct QueryRoot;
+
+#[Object]
+impl QueryRoot {
+    async fn hero(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(
+            desc = "If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode."
+        )]
+        episode: Episode,
+    ) -> Character {
+        if episode == Episode::Empire {
+            Human(ctx.data_unchecked::<StarWars>().luke).into()
+        } else {
+            Droid(ctx.data_unchecked::<StarWars>().artoo).into()
+        }
+    }
+
+    async fn human(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(desc = "id of the human")] id: String,
+    ) -> Option<Human> {
+        ctx.data_unchecked::<StarWars>().human(&id).map(Human)
+    }
+
+    async fn humans(
+        &self,
+        ctx: &Context<'_>,
+        after: Option<String>,
+        before: Option<String>,
+        first: Option<i32>,
+        last: Option<i32>,
+    ) -> FieldResult<Connection<usize, Human, EmptyFields, EmptyFields>> {
+        let humans = ctx
+            .data_unchecked::<StarWars>()
+            .humans()
+            .iter()
+            .copied()
+            .collect::<Vec<_>>();
+        query_characters(after, before, first, last, &humans)
+            .await
+            .map(|conn| conn.map_node(Human))
+    }
+
+    async fn droid(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(desc = "id of the droid")] id: String,
+    ) -> Option<Droid> {
+        ctx.data_unchecked::<StarWars>().droid(&id).map(Droid)
+    }
+
+    async fn droids(
+        &self,
+        ctx: &Context<'_>,
+        after: Option<String>,
+        before: Option<String>,
+        first: Option<i32>,
+        last: Option<i32>,
+    ) -> FieldResult<Connection<usize, Droid, EmptyFields, EmptyFields>> {
+        let droids = ctx
+            .data_unchecked::<StarWars>()
+            .droids()
+            .iter()
+            .copied()
+            .collect::<Vec<_>>();
+        query_characters(after, before, first, last, &droids)
+            .await
+            .map(|conn| conn.map_node(Droid))
+    }
+}
+
+#[derive(Interface)]
+#[graphql(
+    field(name = "id", type = "&str"),
+    field(name = "name", type = "&str"),
+    field(name = "friends", type = "Vec<Character>"),
+    field(name = "appears_in", type = "&'ctx [Episode]")
+)]
+pub enum Character {
+    Human(Human),
+    Droid(Droid),
+}
+
+async fn query_characters(
+    after: Option<String>,
+    before: Option<String>,
+    first: Option<i32>,
+    last: Option<i32>,
+    characters: &[usize],
+) -> FieldResult<Connection<usize, usize, EmptyFields, EmptyFields>> {
+    query(
+        after,
+        before,
+        first,
+        last,
+        |after, before, first, last| async move {
+            let mut start = 0usize;
+            let mut end = characters.len();
+
+            if let Some(after) = after {
+                if after >= characters.len() {
+                    return Ok(Connection::new(false, false));
+                }
+                start = after + 1;
+            }
+
+            if let Some(before) = before {
+                if before == 0 {
+                    return Ok(Connection::new(false, false));
+                }
+                end = before;
+            }
+
+            let mut slice = &characters[start..end];
+
+            if let Some(first) = first {
+                slice = &slice[..first.min(slice.len())];
+                end -= first.min(slice.len());
+            } else if let Some(last) = last {
+                slice = &slice[slice.len() - last.min(slice.len())..];
+                start = end - last.min(slice.len());
+            }
+
+            let mut connection = Connection::new(start > 0, end < characters.len());
+            connection.append(
+                slice
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, item)| Edge::new(start + idx, *item)),
+            );
+
+            FieldResult::Ok(connection)
+        },
+    )
+    .await
+}