Add all method calls to the latest server version

Restructure request module

src/enums.rs

@@ -22,3 +22,22 @@ impl EndpointMapping {
         }
     }
 }
+
+#[derive(Debug)]
+pub enum Method {
+    Get,
+    Put,
+    Delete,
+    Post,
+}
+
+impl PartialEq for Method {
+    fn eq(&self, other: &Self) -> bool {
+        matches!((self, other),
+            (Method::Get, Method::Get) |
+            (Method::Post, Method::Post) |
+            (Method::Put, Method::Put) |
+            (Method::Delete, Method::Delete)
+        )
+    }
+}

src/parser.rs

@@ -1,5 +1,8 @@
-use reqwest::Url;
 use crate::constant;
+use crate::enums;
+use crate::util;
+use reqwest::blocking::Client;
+use reqwest::Url;
 
 const TRANSIT_KEY_LENGTH: usize = 32;
 const TRANSIT_TIME_BUCKET: u64 = 60;
@@ -20,7 +23,6 @@ pub struct ArgConfig {
     pub get_table: String,
 }
 
-
 fn get_env(key: &str, default: &str) -> String {
     match std::env::var(key) {
         Ok(value) => value,
@@ -35,16 +37,34 @@ fn get_env(key: &str, default: &str) -> String {
 }
 
 pub fn load_env(env_file: &String) {
-    let env_file_path = std::env::current_dir()
-        .unwrap_or_default()
-        .join(env_file);
+    let env_file_path = std::env::current_dir().unwrap_or_default().join(env_file);
     let _ = dotenv::from_path(env_file_path.as_path());
 }
 
 pub fn default_env_file() -> String {
-    std::env::var("env_file")
-        .unwrap_or(std::env::var("ENV_FILE")
-            .unwrap_or(".env".to_string()))
+    std::env::var("env_file").unwrap_or(std::env::var("ENV_FILE").unwrap_or(".env".to_string()))
+}
+
+fn health_check(server_url: &Url) {
+    let client = Client::new();
+    let url = util::urljoin(&[
+        server_url.as_ref(),
+        enums::EndpointMapping::Health.as_str(),
+    ]);
+    let request = client.get(url);
+    match request.send() {
+        Ok(init_response) => match init_response.error_for_status() {
+            Ok(_) => {}
+            Err(err) => {
+                println!("{}", err);
+                std::process::exit(1)
+            }
+        },
+        Err(err) => {
+            println!("{}", err);
+            std::process::exit(1)
+        }
+    }
 }
 
 pub fn env_variables() -> EnvConfig {
@@ -55,15 +75,19 @@ pub fn env_variables() -> EnvConfig {
     let vault_server_env = get_env("VAULT_SERVER", "");
     let vault_server = match Url::parse(&vault_server_env) {
         Ok(url) => url,
-        Err(_e) => panic!("Failed to parse vault address"),
+        Err(_) => {
+            println!("Failed to parse vault address");
+            std::process::exit(1)
+        }
     };
+    health_check(&vault_server);
     let transit_key_length = match std::env::var("TRANSMIT_KEY_LENGTH") {
         Ok(value) => value.parse::<usize>().unwrap_or(TRANSIT_KEY_LENGTH),
         Err(_) => TRANSIT_KEY_LENGTH,
     };
     let transit_time_bucket = match std::env::var("TRANSIT_TIME_BUCKET") {
         Ok(value) => value.parse::<u64>().unwrap_or(TRANSIT_TIME_BUCKET),
-        Err(_) => TRANSIT_TIME_BUCKET
+        Err(_) => TRANSIT_TIME_BUCKET,
     };
     EnvConfig {
         vault_server,
@@ -74,7 +98,6 @@ pub fn env_variables() -> EnvConfig {
     }
 }
 
-
 /// Parses and returns the command-line arguments and environment variables.
 ///
 /// # Returns
@@ -98,7 +121,8 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
                 let helper = "VaultAPI-Client takes the arguments, --env_file and --version/-v\n\n\
                 --env_file: Custom filename to load the environment variables. Defaults to '.env'\n\
                 --cipher: Cipher text to decrypt\n\
-                --version: Get the package version.\n".to_string();
+                --version: Get the package version.\n"
+                    .to_string();
                 println!("Usage: {} [OPTIONS]\n\n{}", args[0], helper);
                 std::process::exit(0)
             }

src/request.rs

@@ -5,10 +5,13 @@ use reqwest::blocking::Client;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::process::exit;
+use crate::enums::Method;
 
-pub struct RequestMaterials {
+pub struct PreparedRequest {
     pub url: String,
+    pub method: Method,
     pub params: HashMap<String, String>,
+    pub payload: HashMap<String, Value>,
     pub headers: HashMap<String, String>,
 }
 
@@ -34,7 +37,7 @@ pub fn auth_headers(apikey: &String) -> HashMap<String, String> {
 ///
 /// # Returns
 /// * A `RequestMaterials` struct containing auth headers, query parameters, and the request URL.
-fn create_request_materials(arg_config: &ArgConfig, env_config: &EnvConfig) -> RequestMaterials {
+fn create_request_materials(arg_config: &ArgConfig, env_config: &EnvConfig) -> PreparedRequest {
     // Add URL parameters
     let mut url = String::new();
     let mut params = HashMap::new();
@@ -60,9 +63,11 @@ fn create_request_materials(arg_config: &ArgConfig, env_config: &EnvConfig) -> R
         println!("Required parameters unfilled!");
         exit(1)
     }
-    RequestMaterials {
+    PreparedRequest {
         url,
+        method: Method::Get,
         params,
+        payload: HashMap::new(),
         headers: auth_headers(&env_config.apikey),
     }
 }
@@ -102,8 +107,8 @@ pub fn decrypt_response(env_config: &EnvConfig, response: &Value) -> Result<Valu
 /// # Returns
 /// * A `Result<Value, String>` containing deciphered content.
 pub fn server_connection(arg_config: &ArgConfig, env_config: &EnvConfig) -> Result<Value, String> {
-    let request = create_request_materials(arg_config, env_config);
-    let response = make_request(&request.url, Some(request.headers), Some(request.params));
+    let prepared_request = create_request_materials(arg_config, env_config);
+    let response = make_request(prepared_request);
     decrypt_response(env_config, &response)
 }
 
@@ -117,31 +122,39 @@ pub fn server_connection(arg_config: &ArgConfig, env_config: &EnvConfig) -> Resu
 /// # Returns
 /// * A `Value` object containing the server response.
 pub fn make_request(
-    server_url: &str,
-    headers: Option<HashMap<String, String>>,
-    params: Option<HashMap<String, String>>,
+    prepared_request: PreparedRequest
 ) -> Value {
     // Create a reqwest client
     let client = Client::new();
 
     // Build the URL with parameters if provided
     // todo: Remove expect and construct a match
-    let mut url = reqwest::Url::parse(server_url).expect("Invalid URL");
-    if let Some(query_params) = params {
-        let query: Vec<(String, String)> = query_params.into_iter().collect();
+    let mut url = reqwest::Url::parse(&prepared_request.url).expect("Invalid URL");
+    if !prepared_request.params.is_empty() {
+        let query: Vec<(String, String)> = prepared_request.params.into_iter().collect();
         url.query_pairs_mut().extend_pairs(query);
     }
 
     // Prepare the request builder
-    let mut request = client.get(url);
+    let mut request = match prepared_request.method {
+        Method::Get => client.get(url),
+        Method::Post => client.post(url),
+        Method::Put => client.put(url),
+        Method::Delete => client.delete(url),
+    };
 
     // Add headers if provided
-    if let Some(custom_headers) = headers {
-        for (key, value) in custom_headers {
+    if !prepared_request.headers.is_empty() {
+        for (key, value) in prepared_request.headers {
             request = request.header(&key, value);
         }
     }
 
+    // Add JSON payload if provided
+    if !prepared_request.payload.is_empty() {
+        request = request.json(&prepared_request.payload)
+    }
+
     // Make the request
     match request.send() {
         Ok(init_response) => {
@@ -170,7 +183,7 @@ pub fn make_request(
             }
         }
         Err(err) => {
-            println!("Failed to fetch data from {}: {}", server_url, err);
+            println!("Failed to fetch data from {}: {}", prepared_request.url, err);
             exit(1);
         }
     }

src/routes.rs

@@ -1,8 +1,25 @@
+use crate::enums::Method;
+use crate::parser::EnvConfig;
 use crate::{enums, parser, request, util};
-use serde_json::Value;
+use serde_json::{to_value, Value};
 use std::collections::HashMap;
 use std::process::exit;
 
+fn table_request(
+    url: String,
+    method: Method,
+    table_name: &String,
+    env_config: &EnvConfig,
+) -> request::PreparedRequest {
+    request::PreparedRequest {
+        url: url.to_string(),
+        method,
+        params: HashMap::from([("table_name".to_string(), table_name.to_string())]),
+        payload: HashMap::new(),
+        headers: request::auth_headers(&env_config.apikey),
+    }
+}
+
 pub fn get_secret(key: &String, table: &String) -> Result<Value, String> {
     let env_config = parser::env_variables();
     let url = util::urljoin(&[
@@ -13,12 +30,14 @@ pub fn get_secret(key: &String, table: &String) -> Result<Value, String> {
         ("table_name".to_string(), table.to_string()),
         ("key".to_string(), key.to_string()),
     ]);
-    let request = request::RequestMaterials {
+    let request = request::PreparedRequest {
         url,
+        method: Method::Get,
         params,
+        payload: HashMap::new(),
         headers: request::auth_headers(&env_config.apikey),
     };
-    let response = request::make_request(&request.url, Some(request.headers), Some(request.params));
+    let response = request::make_request(request);
     request::decrypt_response(&env_config, &response)
 }
 
@@ -28,13 +47,8 @@ pub fn get_table(table: &String) -> Result<Value, String> {
         env_config.vault_server.as_ref(),
         enums::EndpointMapping::GetTable.as_str(),
     ]);
-    let params = HashMap::from([("table_name".to_string(), table.to_string())]);
-    let request = request::RequestMaterials {
-        url,
-        params,
-        headers: request::auth_headers(&env_config.apikey),
-    };
-    let response = request::make_request(&request.url, Some(request.headers), Some(request.params));
+    let request = table_request(url, Method::Get, table, &env_config);
+    let response = request::make_request(request);
     request::decrypt_response(&env_config, &response)
 }
 
@@ -44,12 +58,14 @@ pub fn list_tables() -> Vec<String> {
         env_config.vault_server.as_ref(),
         enums::EndpointMapping::ListTables.as_str(),
     ]);
-    let request = request::RequestMaterials {
+    let request = request::PreparedRequest {
         url,
+        method: Method::Get,
         params: HashMap::new(),
+        payload: HashMap::new(),
         headers: request::auth_headers(&env_config.apikey),
     };
-    let response = request::make_request(&request.url, Some(request.headers), Some(request.params));
+    let response = request::make_request(request);
     match response {
         Value::Array(array) => {
             let mut table_names: Vec<String> = Vec::new();
@@ -71,3 +87,52 @@ pub fn list_tables() -> Vec<String> {
         }
     }
 }
+
+pub fn put_secret(secrets: &HashMap<String, String>, table_name: &String) -> Value {
+    let env_config = parser::env_variables();
+    let url = util::urljoin(&[
+        env_config.vault_server.as_ref(),
+        enums::EndpointMapping::PutSecret.as_str(),
+    ]);
+    let sec: Value = to_value(secrets.to_owned()).unwrap();
+    let mut payload = HashMap::new();
+    payload.insert("secrets".to_string(), sec);
+    payload.insert("table_name".to_string(), Value::String(table_name.to_string()));
+    let request = request::PreparedRequest {
+        url,
+        method: Method::Put,
+        params: HashMap::new(),
+        payload,
+        headers: request::auth_headers(&env_config.apikey),
+    };
+    request::make_request(request)
+}
+
+pub fn delete_secret(key: &String, table_name: &String) -> Value {
+    let env_config = parser::env_variables();
+    let url = util::urljoin(&[
+        env_config.vault_server.as_ref(),
+        enums::EndpointMapping::DeleteSecret.as_str(),
+    ]);
+    let request = request::PreparedRequest {
+        url,
+        method: Method::Delete,
+        params: HashMap::new(),
+        payload: HashMap::from([
+            ("key".to_string(), Value::String(key.to_string())),
+            ("table_name".to_string(), Value::String(table_name.to_string())),
+        ]),
+        headers: request::auth_headers(&env_config.apikey),
+    };
+    request::make_request(request)
+}
+
+pub fn create_table(table_name: &String) -> Value {
+    let env_config = parser::env_variables();
+    let url = util::urljoin(&[
+        env_config.vault_server.as_ref(),
+        enums::EndpointMapping::CreateTable.as_str(),
+    ]);
+    let request = table_request(url, Method::Post, table_name, &env_config);
+    request::make_request(request)
+}