General Cleanup and Performance (#5)

* Organization for GQL addition

* Removed unused deps

* Stop cloning everything...

* guild lookup schema

Cargo.toml

@@ -19,3 +19,6 @@ postgres_array = "0.10.0"
 bb8 = "0.4.2"
 bb8-postgres = "0.4.0"
 regex = "1.3.9"
+warp = "0.2.0"
+async-graphql = "1.16"
+async-graphql-warp = "1.14.9"

src/commands/admin/kill.rs → src/discord/commands/admin/kill.rs

@@ -1,4 +1,4 @@
-use crate::ShardManagerContainer;
+use crate::discord::shard::ShardManagerContainer;
 use serenity::{
   framework::standard::{macros::command, CommandResult},
   model::prelude::Message,

src/commands/admin/ping.rs → src/discord/commands/admin/ping.rs

@@ -1,4 +1,4 @@
-use crate::ShardManagerContainer;
+use crate::discord::shard::ShardManagerContainer;
 use serenity::{
   client::bridge::gateway::ShardId,
   framework::standard::{macros::command, CommandResult},

src/commands/admin/sql.rs → src/discord/commands/admin/sql.rs

@@ -1,4 +1,4 @@
-use crate::PostgresPool;
+use crate::discord::shard::PostgresPool;
 use regex::Regex;
 use serenity::{
   framework::standard::{macros::command, Args, CommandResult},

src/discord/connection.rs

@@ -0,0 +1,51 @@
+use crate::discord::{
+  commands::{help::*, *},
+  handler,
+  shard::{PostgresPool, ShardManagerContainer},
+};
+use bb8_postgres::PostgresConnectionManager;
+use postgres::NoTls;
+use serenity::client::bridge::gateway::ShardManager;
+use serenity::prelude::Mutex;
+use serenity::{client::Client, framework::standard::StandardFramework, model::id::UserId};
+use std::{collections::HashSet, env, sync::Arc};
+
+pub async fn setup(pool: &bb8::Pool<PostgresConnectionManager<NoTls>>) -> Arc<Mutex<ShardManager>> {
+  let token: String = env::var("DISCORD_TOKEN").expect("Missing token env");
+
+  let mut owners = HashSet::new();
+  owners.insert(UserId(83281345949728768));
+
+  let framework = StandardFramework::new()
+    .configure(|c| {
+      c.owners(owners)
+        .prefix("!")
+        .ignore_bots(true)
+        .ignore_webhooks(true)
+        .allow_dm(false)
+    })
+    .help(&HELP)
+    // .group(&GENERAL_GROUP)
+    .group(&ADMIN_GROUP);
+
+  let mut client: Client = Client::new(&token)
+    .event_handler(handler::Handler)
+    .framework(framework)
+    .await
+    .expect("Error creating client");
+
+  {
+    let mut data = client.data.write().await;
+    data.insert::<ShardManagerContainer>(Arc::clone(&client.shard_manager));
+    data.insert::<PostgresPool>(pool.clone());
+  }
+
+  let shards = Arc::clone(&client.shard_manager);
+  tokio::spawn(async move {
+    client
+      .start_autosharded()
+      .await
+      .expect("Failed to start autosharding.");
+  });
+  shards
+}

src/handler.rs → src/discord/handler.rs

@@ -64,26 +64,23 @@ impl EventHandler for Handler {
       return;
     }
 
-    let permitted = automod::automod(ctx.clone(), msg.clone())
-      .await
-      .ok()
-      .unwrap();
+    let permitted = automod::automod(&ctx, &msg).await.ok().unwrap();
 
-    store::message(ctx.clone(), msg.clone(), permitted).await;
+    store::message(&ctx, &msg, permitted).await;
 
     if permitted {
-      mention::tim(ctx.clone(), msg.clone()).await;
+      mention::tim(&ctx, &msg).await;
     }
   }
   async fn guild_create(&self, ctx: Context, guild: Guild, is_new: bool) {
-    if !is_new && !get::is_new_guild(ctx.clone(), guild.id.clone()).await {
+    if !is_new && !get::is_new_guild(&ctx, guild.id).await {
       return;
     }
 
     let target = &format!("processing::{}", guild.id)[..];
     log::info!(target: target, "{}", guild.id);
 
-    store::guild(ctx.clone(), guild.clone()).await;
+    store::guild(&ctx, &guild).await;
 
     let mut after: Option<UserId> = Some(UserId(0));
     while after.is_some() {
@@ -96,11 +93,11 @@ impl EventHandler for Handler {
         Some(member) => Some(member.user.id),
         None => None,
       };
-      store::members(ctx.clone(), members.clone()).await;
+      store::members(&ctx, members).await;
     }
   }
   async fn guild_role_create(&self, ctx: Context, guild_id: GuildId, new: Role) {
-    store::role(ctx, guild_id, &new).await;
+    store::role(&ctx, guild_id, &new).await;
   }
   async fn guild_role_delete(
     &self,
@@ -109,19 +106,19 @@ impl EventHandler for Handler {
     role_id: RoleId,
     _: Option<Role>,
   ) {
-    delete::role(ctx, guild_id, role_id).await;
+    delete::role(&ctx, guild_id, role_id).await;
   }
   async fn guild_role_update(&self, ctx: Context, guild_id: GuildId, _: Option<Role>, new: Role) {
-    store::role(ctx, guild_id, &new).await;
+    store::role(&ctx, guild_id, &new).await;
   }
   async fn guild_update(&self, ctx: Context, _: Option<Guild>, guild: PartialGuild) {
     store::part_guild(ctx, guild).await;
   }
   async fn guild_member_addition(&self, ctx: Context, _: GuildId, member: Member) {
-    store::members(ctx, vec![member]).await;
+    store::members(&ctx, vec![member]).await;
   }
   async fn guild_member_update(&self, ctx: Context, _: Option<Member>, member: Member) {
-    store::members(ctx, vec![member]).await;
+    store::members(&ctx, vec![member]).await;
   }
   async fn guild_member_removal(
     &self,

src/discord/mod.rs

@@ -0,0 +1,4 @@
+pub mod commands;
+pub mod connection;
+pub mod handler;
+pub mod shard;

src/graphql/mod.rs

@@ -0,0 +1,2 @@
+pub mod schema;
+pub mod server;

src/graphql/schema.rs

@@ -0,0 +1,69 @@
+use async_graphql::{Context, FieldError, FieldResult};
+use bb8_postgres::PostgresConnectionManager;
+use postgres::NoTls;
+
+pub type PostgresPool = bb8::Pool<PostgresConnectionManager<NoTls>>;
+
+pub struct Guild {
+  pub id: i64,
+  pub name: String,
+}
+
+#[async_graphql::Object]
+impl Guild {
+  async fn id(&self) -> &i64 {
+    &self.id
+  }
+
+  async fn created_at(&self) -> i64 {
+    (&self.id >> 22) + 1420070400000
+  }
+
+  async fn name(&self) -> &str {
+    &self.name
+  }
+}
+
+pub struct QueryRoot;
+
+#[async_graphql::Object]
+impl QueryRoot {
+  async fn guild(&self, ctx: &Context<'_>, id: i64) -> FieldResult<Guild> {
+    let pool = match ctx.data_unchecked::<PostgresPool>().get().await {
+      Ok(pool) => pool,
+      Err(_) => return Err(FieldError("Fatal db pool error".to_string(), None)),
+    };
+
+    let guild = match pool
+      .query("SELECT id, name FROM guilds WHERE id = $1", &[&id])
+      .await
+    {
+      Ok(guild) => guild,
+      Err(e) => {
+        println!("{}", e);
+        return Err(FieldError("Failed to fetch guild".to_string(), None));
+      }
+    };
+
+    if guild.len() == 0 {
+      return Err(FieldError("Guild not found".to_string(), None));
+    }
+
+    let guild = &guild[0];
+
+    Ok(Guild {
+      id: guild.get(0),
+      name: guild.get(1),
+    })
+  }
+}
+
+pub struct MutationRoot;
+
+#[async_graphql::Object]
+impl MutationRoot {}
+
+pub struct SubscriptionRoot;
+
+#[async_graphql::Subscription]
+impl SubscriptionRoot {}

src/graphql/server.rs

@@ -0,0 +1,34 @@
+use crate::graphql::schema::{MutationRoot, PostgresPool, QueryRoot, SubscriptionRoot};
+use async_graphql::http::{playground_source, GraphQLPlaygroundConfig};
+use async_graphql::{QueryBuilder, Schema};
+use async_graphql_warp::{graphql_subscription, GQLResponse};
+use std::convert::Infallible;
+use warp::{http::Response, Filter};
+
+pub async fn start(pool: &PostgresPool) {
+  let schema = Schema::build(QueryRoot, MutationRoot, SubscriptionRoot)
+    .data(pool.clone())
+    .finish();
+
+  println!("Playground: http://localhost:8000");
+
+  let graphql_post = async_graphql_warp::graphql(schema.clone()).and_then(
+    |(schema, builder): (_, QueryBuilder)| async move {
+      let resp = builder.execute(&schema).await;
+      Ok::<_, Infallible>(GQLResponse::from(resp))
+    },
+  );
+
+  let graphql_playground = warp::path::end().and(warp::get()).map(|| {
+    Response::builder()
+      .header("content-type", "text/html")
+      .body(playground_source(
+        GraphQLPlaygroundConfig::new("/").subscription_endpoint("/"),
+      ))
+  });
+
+  let routes = graphql_subscription(schema)
+    .or(graphql_playground)
+    .or(graphql_post);
+  warp::serve(routes).run(([0, 0, 0, 0], 8000)).await;
+}

src/main.rs

@@ -1,56 +1,20 @@
-mod commands;
-mod handler;
+mod discord;
+mod graphql;
 mod postgres;
-mod shard;
 mod twitch;
 mod utils;
 
-use crate::postgres::connection;
-use commands::help::*;
-use commands::*;
 use dotenv;
-use serenity::{client::Client, framework::standard::StandardFramework, model::id::UserId};
-use shard::{PostgresPool, ShardManagerContainer};
-use std::{collections::HashSet, env, sync::Arc};
 
 #[tokio::main]
 async fn main() {
   dotenv::dotenv().ok();
   pretty_env_logger::init();
 
-  let pool = connection::setup().await.expect("Failed to setup postgres");
-
-  let token: String = env::var("DISCORD_TOKEN").expect("Missing token env");
-
-  let mut owners = HashSet::new();
-  owners.insert(UserId(83281345949728768));
-
-  let framework = StandardFramework::new()
-    .configure(|c| {
-      c.owners(owners)
-        .prefix("!")
-        .ignore_bots(true)
-        .ignore_webhooks(true)
-        .allow_dm(false)
-    })
-    .help(&HELP)
-    // .group(&GENERAL_GROUP)
-    .group(&ADMIN_GROUP);
-
-  let mut client: Client = Client::new(&token)
-    .event_handler(handler::Handler)
-    .framework(framework)
+  let pool = crate::postgres::connection::setup()
     .await
-    .expect("Error creating client");
-
-  {
-    let mut data = client.data.write().await;
-    data.insert::<ShardManagerContainer>(Arc::clone(&client.shard_manager));
-    data.insert::<PostgresPool>(pool.clone());
-  }
+    .expect("Failed to setup postgres");
 
-  client
-    .start_autosharded()
-    .await
-    .expect("Failed to start autosharding.");
+  crate::discord::connection::setup(&pool).await;
+  crate::graphql::server::start(&pool).await;
 }

src/postgres/delete.rs

@@ -1,11 +1,11 @@
-use crate::PostgresPool;
+use crate::discord::shard::PostgresPool;
 use serenity::{
   client::Context,
   model::id::{GuildId, RoleId, UserId},
 };
 use std::convert::TryFrom;
 
-pub async fn role(ctx: Context, guild_id: GuildId, role_id: RoleId) {
+pub async fn role(ctx: &Context, guild_id: GuildId, role_id: RoleId) {
   let data = ctx.data.read().await;
   let pool = match data.get::<PostgresPool>() {
     Some(v) => v.get().await.unwrap(),

src/postgres/get.rs

@@ -1,8 +1,8 @@
-use crate::PostgresPool;
+use crate::discord::shard::PostgresPool;
 use serenity::{client::Context, model::id::GuildId};
 use std::convert::TryFrom;
 
-pub async fn is_new_guild(ctx: Context, guild_id: GuildId) -> bool {
+pub async fn is_new_guild(ctx: &Context, guild_id: GuildId) -> bool {
   let data = ctx.data.read().await;
   let pool = match data.get::<PostgresPool>() {
     Some(v) => v.get().await.unwrap(),