in-memory database configs

Author: naomijub

Cargo.toml

@@ -32,7 +32,8 @@ structopt = "0.3"
 bytes = "1.0.0"
 toml = "0.4.2"
 convert_case = "0.4"
+clap = { version = "2.33", default-features = false }
 
 [[bin]]
-name = "cargo-actix"
+name = "actix-cli"
 path = "src/main.rs"

README.md

@@ -5,11 +5,13 @@ CLI to create web services with Actix
 - [x] Fault-tolerant option can be enabled to use Bastion
 - [x] Logger middleware option can be enabled with `--request-logger` flag
 - [x] Basic CRUD controllers
-- [ ] Databa configurations
-- [ ] Read routes configs from `Config.toml`
+- [ ] `Unwrap`s to Crate Error
+- [ ] Database configurations
 - [ ] Auth middleware option can be enabled with `--auth` flag
-- [ ] Read models configs from `Config.toml`
 - [ ] Basic Docker config can be enabled with flag
+- [ ] Read routes configs from `Config.toml`
+- [ ] Read models configs from `Config.toml`
+
 
 > Not defining a Database will mean a `Context` will be created to support a basic `HashMap`.
  
@@ -26,17 +28,19 @@ CLI to create web services with Actix
 
 ```sh
 actix-cli 0.1.0
-A CLI to create actix-web projects boilerplate.
+A CLI to create actix-web projects boilerplate
 
 USAGE:
-    actix-cli [OPTIONS] --name <name>
+    actix-cli [OPTIONS] --context <context> --name <name>
 
 FLAGS:
     -h, --help       Prints help information
     -V, --version    Prints version information
 
 OPTIONS:
     -c, --config-file <config-file>          Config.toml file path
+        --context <context>                  Which database configuration. Currently only `InMemory` allowed [possible
+                                             values: InMemory]
     -f, --fault-tolerant <fault-tolerant>    Enables Bastion for fault tolerant system [default: true]
     -n, --name <name>                        Defines project name in Cargo.toml
     -r, --request-logger <request-logger>    Enables request logger as `[IP:%a DATETIME:%t REQUEST:\"%r\" STATUS: %s
@@ -48,6 +52,7 @@ OPTIONS:
 * `request-logger`: `bool`.
 * `name`: `String`.
 * `config-file`: `std::path::PathBuf`.
+* `context`: case insetive enum containing `InMemory` and in the future `PostgresDB` and `DynamoDB`.
 
 ### Example
 

src/config/crud.rs

@@ -63,7 +63,7 @@ fn create_crud_routes(routes: &std::collections::BTreeMap<String, Value>, name:
             "delete" => Ok(format!("
             .route(\"{}\", web::delete().to(delete_{}))", route ,name)), 
             "list" => Ok(format!("
-            .route(\"{}\", web::post().to(show_{}))", route ,name)),
+            .route(\"{}\", web::get().to(show_{}))", route ,name)),
             _ => Err(ActixCliError::UnknwonCrudItem)
         }?;
         routes_def.push_str(&route_config);

src/database/context.rs

@@ -0,0 +1,20 @@
+use clap::arg_enum;
+use convert_case::{Case, Casing};
+
+arg_enum! {
+    #[derive(Debug, Clone)]
+    pub enum PossibleContexts {
+        InMemory
+    }
+}
+
+pub fn possible_contexts(_: PossibleContexts, model_name: String, name: String) -> String {
+    in_memory()
+        .replace("@", &model_name.to_case(Case::Pascal))
+        .replace("{name}", &name.to_case(Case::Snake))
+}
+
+const fn in_memory() -> &'static str {
+"   use {name}::model::{name}::@;
+    let context: std::collections::HashMap<String, @> = std::collections::HashMap::new();"
+}

src/database/mod.rs

@@ -3,6 +3,8 @@ use std::io::prelude::*;
 use std::fs;
 use convert_case::{Case, Casing};
 
+pub mod context;
+
 use crate::config::crud::CrudConfig;
 use crate::error::ActixCliError;
 
@@ -25,13 +27,12 @@ pub fn create_crud_model_rs(name: String, model_config: Option<CrudConfig>) -> R
 
 fn database_info(project_name: &str, module_name: &str) -> String {
     let obj = module_name.to_case(Case::Pascal);
-"use crate::{project_name}::model::{project_name}::{@, @Update};
+"use crate::{project_name}::model::{project_name}::{@, @Update, @Response};
 use std::collections::HashMap;
 pub struct Context(HashMap<String, @>);
 
 impl Context {
-    pub fn new() -> Self {
-        let map: HashMap<String, @> = HashMap::new();
+    pub fn new(map: HashMap<String, @>) -> Self {
         Context{0: map}
     }
 
@@ -56,10 +57,14 @@ impl Context {
         }
     }
 
-    pub fn all(&mut self) -> Vec<Object> {
-        self.0.iter()
-            .map(|(k,v)| *v)
-            .collect::<Vec<Object>>()
+    pub fn all(&mut self) -> Vec<ObjectResponse> {
+        self.0
+            .iter()
+            .map(|(k, v)| ObjectResponse {
+                object: v.clone(),
+                id: k.to_string(),
+            })
+            .collect::<Vec<ObjectResponse>>()
     }
 
     pub fn update(&mut self, key: String, value: ObjectUpdate) -> bool {

src/input.rs

@@ -1,4 +1,5 @@
 use crate::error::ActixCliError;
+use crate::database::context::PossibleContexts;
 use structopt::StructOpt;
 use std::path::PathBuf;
 
@@ -19,6 +20,9 @@ pub struct Opt {
     /// Config.toml file path
     #[structopt(short, long, parse(from_os_str))]
     pub config_file: Option<PathBuf>,
+    /// Which database configuration. Currently only `InMemory` allowed.
+    #[structopt(long, possible_values = &PossibleContexts::variants(), case_insensitive = true)]
+    pub context: PossibleContexts
 
 }
 

src/main.rs

@@ -23,7 +23,7 @@ fn main() {
     let configs = config::crud::create_crud_info(toml, opt.name.clone()).unwrap();
 
     // main.rs
-    let _ = main_core::create_main(opt.name.clone(), opt.fault_tolerant, opt.request_logger).unwrap();
+    let _ = main_core::create_main(opt.name.clone(), opt.fault_tolerant, opt.request_logger, opt.context, configs.clone().unwrap().model_name).unwrap();
     let _ = main_core::routes::create_routes_rs(opt.name.clone(), configs.clone()).unwrap();
     let _ = main_core::controller::create_controllers_rs(opt.name.clone(), configs.clone()).unwrap();
     if configs.is_some() {

src/main_core/controller.rs

@@ -11,50 +11,81 @@ fn crud_controller(name: &str, object: &str) -> String {
     format!("
     use crate::{}::model::{}::*;
     use crate::{}::database::Context;
+    use std::sync::{{Arc, Mutex}};
 
     use actix_web::{{web, HttpResponse, Responder}};
     
-    pub async fn create_{}(state: web::Data<Context>, info: web::Json<@object>) -> impl Responder {{
+    pub async fn create_{}(state: web::Data<Arc<Mutex<Context>>>, info: web::Bytes) -> impl Responder {{
         let id = uuid::Uuid::new_v4();
     
-        unimplemented!()
+        let bytes_str = match String::from_utf8(info.to_vec()) {{
+            Ok(text) => Ok(text),
+            Err(_) => Err(\"bytes parse error\")
+        }};
+    
+        let info = serde_json::from_str(&bytes_str.unwrap()).unwrap();
+        let mut state = state.lock().unwrap();
+        match state.create(id.to_string(), info) {{
+            true => HttpResponse::Created().body(id.to_string()),
+            false => HttpResponse::Conflict().finish(),
+        }}
     }}
     
-    pub async fn show_{}(state: web::Data<Context>) -> impl Responder {{
-        unimplemented!()
+    pub async fn show_{}(state: web::Data<Arc<Mutex<Context>>>) -> impl Responder {{
+        let mut state = state.lock().unwrap();
+        let response = state.all();
+        HttpResponse::Ok().json(response)
     }}
 
-    pub async fn delete_{}(id: web::Path<String>, state: web::Data<Context>) -> impl Responder {{
+    pub async fn delete_{}(id: web::Path<String>, state: web::Data<Arc<Mutex<Context>>>) -> impl Responder {{
         let uuid = id.to_string();
     
         if uuid::Uuid::parse_str(&uuid).is_err() {{
             return HttpResponse::BadRequest().body(\"Id must be a Uuid::V4\");
         }}
     
-        unimplemented!()
+        let mut state = state.lock().unwrap();
+        match state.delete(id.to_string()) {{
+            true => HttpResponse::Ok().finish(),
+            false => HttpResponse::BadRequest().finish(),
+        }}
     }}
     
-    pub async fn get_{}(id: web::Path<String>, state: web::Data<Context>) -> impl Responder {{
+    pub async fn get_{}(id: web::Path<String>, state: web::Data<Arc<Mutex<Context>>>) -> impl Responder {{
         let uuid = id.to_string();
     
         if uuid::Uuid::parse_str(&uuid).is_err() {{
             return HttpResponse::BadRequest().body(\"Id must be a Uuid::V4\");
         }}
     
-        unimplemented!()
+        let mut state = state.lock().unwrap();
+        match state.get(uuid) {{
+            Some(body) => HttpResponse::Ok().json(body),
+            None => HttpResponse::BadRequest().finish(),
+        }}
     }}
     
     pub async fn update_{}(
         id: web::Path<String>,
-        info: web::Json<@objectUpdate>, 
-        state: web::Data<Context>) -> impl Responder {{
+        info: web::Bytes, 
+        state: web::Data<Arc<Mutex<Context>>>) -> impl Responder {{
         let uuid = id.to_string();
     
         if uuid::Uuid::parse_str(&uuid).is_err() {{
             return HttpResponse::BadRequest().body(\"Id must be a Uuid::V4\");
         }}
+
+        let bytes_str = match String::from_utf8(info.to_vec()) {{
+            Ok(text) => Ok(text),
+            Err(_) => Err(\"bytes parse error\")
+        }};
     
-        unimplemented!()
+        let info: ObjectUpdate = serde_json::from_str(&bytes_str.unwrap()).unwrap();
+        let mut state = state.lock().unwrap();
+        match state.update(id.to_string(), info) {{
+            true => HttpResponse::Ok().finish(),
+            false => HttpResponse::BadRequest().finish(),
+        }}
     }}
 ", name, name, name, object, object, object, object, object).replace("@object", &object.to_case(Case::Pascal))
 }

src/main_core/mod.rs

@@ -1,6 +1,7 @@
 use std::fs::OpenOptions;
 use std::io::prelude::*;
 use crate::error::ActixCliError;
+use crate::database::context::{possible_contexts, PossibleContexts};
 
 pub mod routes;
 pub mod controller;
@@ -11,21 +12,25 @@ const fn main_content() -> &'static str {
 use actix_web::middleware::{DefaultHeaders, Logger};
 use actix_web::{App, HttpServer};
 {bastion_use}
+use std::sync::{Arc, Mutex};
 use uuid::Uuid;
 
 mod {name};
 mod {name}_web;
 
 use {name}_web::routes::app_routes;
-//{project_use}
+use {name}::database::Context;
 
 #[actix_rt::main]
 async fn {bastion_main_fn}() -> Result<(), std::io::Error> {
     {not_bastion}
 
-    HttpServer::new(|| {
+    {context}
+    let data = Arc::new(Mutex::new(Context::new(context)));
+
+    HttpServer::new(move || {
         App::new()
-        //{data}
+        .data(data.clone())
         {logger}
         .configure(app_routes)
     })
@@ -68,7 +73,7 @@ const fn logger() -> &'static str {
     "#
 }
 
-pub fn create_main(name: String, bastion: bool, request_logger: bool) -> Result<(), ActixCliError> {
+pub fn create_main(name: String, bastion: bool, request_logger: bool, context: PossibleContexts, model_name: String) -> Result<(), ActixCliError> {
     let mut main = String::from(main_content());
 
     if let Some(idx) = main.find("{bastion_main}") {
@@ -111,7 +116,9 @@ pub fn create_main(name: String, bastion: bool, request_logger: bool) -> Result<
         }
     }
 
-    let main = main.replace("{name}", &name.replace("-", "_"));
+    let main = main
+        .replace("{name}", &name.replace("-", "_"))
+        .replace("{context}", &possible_contexts(context, model_name, name.clone()));
     let mut file = OpenOptions::new()
         .write(true)
         .open(format!("./{}/src/main.rs", name))?;

src/main_core/model.rs

@@ -54,7 +54,12 @@ pub fn create_crud_model_rs(name: String, model_config: Option<CrudConfig>) -> R
             eprintln!("Couldn't create src/{}/model/{}.rs: {}", _name, _name, e);
         }
 
-        if let Err(e) = writeln!(file, "{} ", serde_obj_update(&model_config.unwrap().model_name, model.clone()))
+        if let Err(e) = writeln!(file, "{} ", serde_obj_update(&model_config.clone().unwrap().model_name, model.clone()))
+             {
+            eprintln!("Couldn't create src/{}/model/{}.rs: {}", _name,  _name, e);
+        }
+
+        if let Err(e) = writeln!(file, "{} ", serde_obj_response(&model_config.unwrap().model_name))
              {
             eprintln!("Couldn't create src/{}/model/{}.rs: {}", _name,  _name, e);
         }
@@ -74,4 +79,12 @@ fn serde_obj_update(name: &str, model: String) -> String {
     + &model.replace(": ", ": Option<")
     .replace(",", ">,")
     .replace(&name.to_case(Case::Pascal), &update)
-}
+}
+
+fn serde_obj_response(name: &str) -> String {
+    let response = name.to_case(Case::Pascal) + "Response";
+    String::from(DERIVE) + "
+pub struct " + &response + "
+{pub object: "+ &name.to_case(Case::Pascal) + ", pub id: String,}"
+}
+