Restructure folders (#411)

graphql/juniper-advanced/.env.example

@@ -0,0 +1 @@
+DATABASE_URL=mysql://user:password@127.0.0.1/dbname

graphql/juniper-advanced/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "juniper-advanced"
+version = "2.0.0"
+authors = ["Dwi Sulfahnur <hello@dwisulfahnur.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+actix-web = "3"
+
+juniper = "0.14"
+
+mysql = "17"
+r2d2 = "0.8"
+r2d2_mysql = "17.0"
+
+dotenv = "0.15"
+env_logger = "0.8"
+log = "0.4"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+uuid = { version = "0.8", features = ["serde", "v4"] }

graphql/juniper-advanced/README.md

@@ -0,0 +1,28 @@
+# juniper-advanced
+
+GraphQL Implementation in Rust using Actix, Juniper, and Mysql as Database
+
+# Prerequites
+- Rust Installed
+- MySql as Database
+
+# Database Configuration
+
+Create a new database for this project, and import the existing database schema has been provided named ```mysql-schema.sql```.
+
+Create ```.env``` file on the root directory of this project and set environment variable named ```DATABASE_URL```, the example file has been provided named ```.env.example```, you can see the format on there.
+
+# Run
+
+
+```sh
+# go to the root dir
+cd juniper-advanced
+
+# Run
+cargo run
+```
+
+### GraphQL Playground
+
+http://127.0.0.1:8080/graphiql

graphql/juniper-advanced/mysql-schema.sql

@@ -0,0 +1,77 @@
+-- MySQL dump 10.13  Distrib 8.0.16, for osx10.14 (x86_64)
+--
+-- Host: 127.0.0.1    Database: rust_graphql
+-- ------------------------------------------------------
+-- Server version	8.0.15
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+ SET NAMES utf8mb4 ;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Table structure for table `product`
+--
+
+DROP TABLE IF EXISTS `product`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+ SET character_set_client = utf8mb4 ;
+CREATE TABLE `product` (
+  `id` varchar(255) NOT NULL,
+  `user_id` varchar(255) NOT NULL,
+  `name` varchar(255) NOT NULL,
+  `price` decimal(10,0) NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `product_fk0` (`user_id`),
+  CONSTRAINT `product_fk0` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `product`
+--
+
+LOCK TABLES `product` WRITE;
+/*!40000 ALTER TABLE `product` DISABLE KEYS */;
+/*!40000 ALTER TABLE `product` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `user`
+--
+
+DROP TABLE IF EXISTS `user`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+ SET character_set_client = utf8mb4 ;
+CREATE TABLE `user` (
+  `id` varchar(255) NOT NULL,
+  `name` varchar(255) NOT NULL,
+  `email` varchar(255) NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `email` (`email`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `user`
+--
+
+LOCK TABLES `user` WRITE;
+/*!40000 ALTER TABLE `user` DISABLE KEYS */;
+/*!40000 ALTER TABLE `user` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

graphql/juniper-advanced/src/db.rs

@@ -0,0 +1,12 @@
+use r2d2_mysql::mysql::{Opts, OptsBuilder};
+use r2d2_mysql::MysqlConnectionManager;
+
+pub type Pool = r2d2::Pool<MysqlConnectionManager>;
+
+pub fn get_db_pool() -> Pool {
+    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let opts = Opts::from_url(&db_url).unwrap();
+    let builder = OptsBuilder::from_opts(opts);
+    let manager = MysqlConnectionManager::new(builder);
+    r2d2::Pool::new(manager).expect("Failed to create DB Pool")
+}

graphql/juniper-advanced/src/handlers.rs

@@ -0,0 +1,39 @@
+use actix_web::{web, Error, HttpResponse};
+use juniper::http::graphiql::graphiql_source;
+use juniper::http::GraphQLRequest;
+
+use crate::db::Pool;
+use crate::schemas::root::{create_schema, Context, Schema};
+
+pub async fn graphql(
+    pool: web::Data<Pool>,
+    schema: web::Data<Schema>,
+    data: web::Json<GraphQLRequest>,
+) -> Result<HttpResponse, Error> {
+    let ctx = Context {
+        dbpool: pool.get_ref().to_owned(),
+    };
+    let res = web::block(move || {
+        let res = data.execute(&schema, &ctx);
+        Ok::<_, serde_json::error::Error>(serde_json::to_string(&res)?)
+    })
+    .await
+    .map_err(Error::from)?;
+
+    Ok(HttpResponse::Ok()
+        .content_type("application/json")
+        .body(res))
+}
+
+pub async fn graphql_playground() -> HttpResponse {
+    HttpResponse::Ok()
+        .content_type("text/html; charset=utf-8")
+        .body(graphiql_source("/graphql"))
+}
+
+pub fn register(config: &mut web::ServiceConfig) {
+    config
+        .data(create_schema())
+        .route("/graphql", web::post().to(graphql))
+        .route("/graphiql", web::get().to(graphql_playground));
+}

graphql/juniper-advanced/src/main.rs

@@ -0,0 +1,33 @@
+#[macro_use]
+extern crate juniper;
+extern crate r2d2;
+extern crate r2d2_mysql;
+extern crate serde_json;
+
+use actix_web::{middleware, web, App, HttpServer};
+
+use crate::db::get_db_pool;
+use crate::handlers::register;
+
+mod db;
+mod handlers;
+mod schemas;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    dotenv::dotenv().ok();
+    std::env::set_var("RUST_LOG", "actix_web=info,info");
+    env_logger::init();
+    let pool = get_db_pool();
+
+    HttpServer::new(move || {
+        App::new()
+            .data(pool.clone())
+            .wrap(middleware::Logger::default())
+            .configure(register)
+            .default_service(web::to(|| async { "404" }))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}

graphql/juniper-advanced/src/schemas/mod.rs

@@ -0,0 +1,3 @@
+pub mod product;
+pub mod root;
+pub mod user;

graphql/juniper-advanced/src/schemas/product.rs

@@ -0,0 +1,51 @@
+use mysql::{from_row, params, Error as DBError, Row};
+
+use crate::schemas::root::Context;
+use crate::schemas::user::User;
+
+/// Product
+#[derive(Default, Debug)]
+pub struct Product {
+    pub id: String,
+    pub user_id: String,
+    pub name: String,
+    pub price: f64,
+}
+
+#[juniper::object(Context = Context)]
+impl Product {
+    fn id(&self) -> &str {
+        &self.id
+    }
+    fn user_id(&self) -> &str {
+        &self.user_id
+    }
+    fn name(&self) -> &str {
+        &self.name
+    }
+    fn price(&self) -> f64 {
+        self.price
+    }
+
+    fn user(&self, context: &Context) -> Option<User> {
+        let mut conn = context.dbpool.get().unwrap();
+        let user: Result<Option<Row>, DBError> = conn.first_exec(
+            "SELECT * FROM user WHERE id=:id",
+            params! {"id" => &self.user_id},
+        );
+        if let Err(err) = user {
+            None
+        } else {
+            let (id, name, email) = from_row(user.unwrap().unwrap());
+            Some(User { id, name, email })
+        }
+    }
+}
+
+#[derive(GraphQLInputObject)]
+#[graphql(description = "Product Input")]
+pub struct ProductInput {
+    pub user_id: String,
+    pub name: String,
+    pub price: f64,
+}

graphql/juniper-advanced/src/schemas/root.rs

@@ -0,0 +1,175 @@
+use juniper::{FieldError, FieldResult, RootNode};
+use mysql::{from_row, params, Error as DBError, Row};
+
+use crate::db::Pool;
+
+use super::product::{Product, ProductInput};
+use super::user::{User, UserInput};
+
+pub struct Context {
+    pub dbpool: Pool,
+}
+
+impl juniper::Context for Context {}
+
+pub struct QueryRoot;
+
+#[juniper::object(Context = Context)]
+impl QueryRoot {
+    #[graphql(description = "List of all users")]
+    fn users(context: &Context) -> FieldResult<Vec<User>> {
+        let mut conn = context.dbpool.get().unwrap();
+        let users = conn
+            .prep_exec("select * from user", ())
+            .map(|result| {
+                result
+                    .map(|x| x.unwrap())
+                    .map(|mut row| {
+                        let (id, name, email) = from_row(row);
+                        User { id, name, email }
+                    })
+                    .collect()
+            })
+            .unwrap();
+        Ok(users)
+    }
+
+    #[graphql(description = "Get Single user reference by user ID")]
+    fn user(context: &Context, id: String) -> FieldResult<User> {
+        let mut conn = context.dbpool.get().unwrap();
+
+        let user: Result<Option<Row>, DBError> =
+            conn.first_exec("SELECT * FROM user WHERE id=:id", params! {"id" => id});
+
+        if let Err(err) = user {
+            return Err(FieldError::new(
+                "User Not Found",
+                graphql_value!({ "not_found": "user not found" }),
+            ));
+        }
+
+        let (id, name, email) = from_row(user.unwrap().unwrap());
+        Ok(User { id, name, email })
+    }
+
+    #[graphql(description = "List of all users")]
+    fn products(context: &Context) -> FieldResult<Vec<Product>> {
+        let mut conn = context.dbpool.get().unwrap();
+        let products = conn
+            .prep_exec("select * from product", ())
+            .map(|result| {
+                result
+                    .map(|x| x.unwrap())
+                    .map(|mut row| {
+                        let (id, user_id, name, price) = from_row(row);
+                        Product {
+                            id,
+                            user_id,
+                            name,
+                            price,
+                        }
+                    })
+                    .collect()
+            })
+            .unwrap();
+        Ok(products)
+    }
+
+    #[graphql(description = "Get Single user reference by user ID")]
+    fn product(context: &Context, id: String) -> FieldResult<Product> {
+        let mut conn = context.dbpool.get().unwrap();
+        let product: Result<Option<Row>, DBError> =
+            conn.first_exec("SELECT * FROM user WHERE id=:id", params! {"id" => id});
+        if let Err(err) = product {
+            return Err(FieldError::new(
+                "Product Not Found",
+                graphql_value!({ "not_found": "product not found" }),
+            ));
+        }
+
+        let (id, user_id, name, price) = from_row(product.unwrap().unwrap());
+        Ok(Product {
+            id,
+            user_id,
+            name,
+            price,
+        })
+    }
+}
+
+pub struct MutationRoot;
+
+#[juniper::object(Context = Context)]
+impl MutationRoot {
+    fn create_user(context: &Context, user: UserInput) -> FieldResult<User> {
+        let mut conn = context.dbpool.get().unwrap();
+        let new_id = uuid::Uuid::new_v4().to_simple().to_string();
+
+        let insert: Result<Option<Row>, DBError> = conn.first_exec(
+            "INSERT INTO user(id, name, email) VALUES(:id, :name, :email)",
+            params! {
+                "id" => &new_id,
+                "name" => &user.name,
+                "email" => &user.email,
+            },
+        );
+
+        match insert {
+            Ok(opt_row) => Ok(User {
+                id: new_id,
+                name: user.name,
+                email: user.email,
+            }),
+            Err(err) => {
+                let msg = match err {
+                    DBError::MySqlError(err) => err.message,
+                    _ => "internal error".to_owned(),
+                };
+                Err(FieldError::new(
+                    "Failed to create new user",
+                    graphql_value!({ "internal_error": msg }),
+                ))
+            }
+        }
+    }
+
+    fn create_product(context: &Context, product: ProductInput) -> FieldResult<Product> {
+        let mut conn = context.dbpool.get().unwrap();
+        let new_id = uuid::Uuid::new_v4().to_simple().to_string();
+
+        let insert: Result<Option<Row>, DBError> = conn.first_exec(
+            "INSERT INTO product(id, user_id, name, price) VALUES(:id, :user_id, :name, :price)",
+            params! {
+                "id" => &new_id,
+                "user_id" => &product.user_id,
+                "name" => &product.name,
+                "price" => &product.price.to_owned(),
+            },
+        );
+
+        match insert {
+            Ok(opt_row) => Ok(Product {
+                id: new_id,
+                user_id: product.user_id,
+                name: product.name,
+                price: product.price,
+            }),
+            Err(err) => {
+                let msg = match err {
+                    DBError::MySqlError(err) => err.message,
+                    _ => "internal error".to_owned(),
+                };
+                Err(FieldError::new(
+                    "Failed to create new product",
+                    graphql_value!({ "internal_error": msg }),
+                ))
+            }
+        }
+    }
+}
+
+pub type Schema = RootNode<'static, QueryRoot, MutationRoot>;
+
+pub fn create_schema() -> Schema {
+    Schema::new(QueryRoot, MutationRoot)
+}

graphql/juniper-advanced/src/schemas/user.rs

@@ -0,0 +1,58 @@
+use mysql::{from_row, params};
+
+use crate::schemas::product::Product;
+use crate::schemas::root::Context;
+
+/// User
+#[derive(Default, Debug)]
+pub struct User {
+    pub id: String,
+    pub name: String,
+    pub email: String,
+}
+
+#[derive(GraphQLInputObject)]
+#[graphql(description = "User Input")]
+pub struct UserInput {
+    pub name: String,
+    pub email: String,
+}
+
+#[juniper::object(Context = Context)]
+impl User {
+    fn id(&self) -> &str {
+        &self.id
+    }
+    fn name(&self) -> &str {
+        &self.name
+    }
+    fn email(&self) -> &str {
+        &self.email
+    }
+
+    fn products(&self, context: &Context) -> Vec<Product> {
+        let mut conn = context.dbpool.get().unwrap();
+
+        conn.prep_exec(
+            "select * from product where user_id=:user_id",
+            params! {
+                "user_id" => &self.id
+            },
+        )
+        .map(|result| {
+            result
+                .map(|x| x.unwrap())
+                .map(|mut row| {
+                    let (id, user_id, name, price) = from_row(row);
+                    Product {
+                        id,
+                        user_id,
+                        name,
+                        price,
+                    }
+                })
+                .collect()
+        })
+        .unwrap()
+    }
+}