Kind of Initial CommentHEADmaster

Implement basic way of testing various http methods via simple cli interface. Also write basic config file kind of parser.

8 files changed, 344 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..dc50474
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+debug/
+target/
+Cargo.lock
+**/*.rs.bk
+*.pdb
+rust-project.json
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..98154e1
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,4 @@
+[workspace]
+members = ["main", "config"]
+
+resolver = "3"
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..d88ceea
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,24 @@
+FROM lukemathwalker/cargo-chef:latest AS chef
+WORKDIR /app
+
+FROM chef AS planner
+COPY . .
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM chef AS builder
+COPY --from=planner /app/recipe.json recipe.json
+RUN cargo chef cook --release --recipe-path recipe.json
+COPY . .
+RUN cargo build --release --bin macmeeting_back
+
+FROM debian:bookworm-slim AS runtime
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+   libssl3 \
+   libpq-dev \
+   && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/target/release/macmeeting_back /usr/local/bin
+
+ENTRYPOINT ["/usr/local/bin/macmeeting_back"]
diff --git a/apitool.toml b/apitool.toml
new file mode 100644
index 0000000..7086f4c
--- /dev/null
+++ b/apitool.toml
@@ -0,0 +1,8 @@
+
+[default]
+headers = [
+  "Authorization: Bearer YOUR_TOKEN",
+  "Content-Type: application/json"
+]
+
+indent = 4
diff --git a/config/Cargo.toml b/config/Cargo.toml
new file mode 100644
index 0000000..b7a0be1
--- /dev/null
+++ b/config/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "config"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+toml = "0.7"
+serde = { version = "1.0", features = ["derive"] }
diff --git a/config/src/lib.rs b/config/src/lib.rs
new file mode 100644
index 0000000..d83b615
--- /dev/null
+++ b/config/src/lib.rs
@@ -0,0 +1,94 @@
+use serde::Deserialize;
+use std::fs;
+use std::path::Path;
+
+#[derive(Debug, Deserialize)]
+pub struct DefaultConfig {
+    pub headers: Option<Vec<String>>,
+    pub indent: Option<usize>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Config {
+    pub default: Option<DefaultConfig>,
+}
+
+impl Config {
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, Box<dyn std::error::Error>> {
+        let content = fs::read_to_string(path)?;
+        let config: Config = toml::from_str(&content)?;
+        Ok(config)
+    }
+
+    pub fn headers(&self) -> Vec<String> {
+        self.default
+            .as_ref()
+            .and_then(|d| d.headers.clone())
+            .unwrap_or_default()
+    }
+
+    pub fn indent(&self) -> usize {
+        self.default.as_ref().and_then(|d| d.indent).unwrap_or(2)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::env;
+    use std::fs::write;
+
+    #[test]
+    fn test_from_file_with_realistic_headers() {
+        let toml_content = r#"
+        [default]
+        headers = [
+            "Authorization: Bearer YOUR_TOKEN",
+            "Content-Type: application/json"
+        ]
+        indent = 4
+    "#;
+
+        let tmp_path = std::env::temp_dir().join("test_real_config.toml");
+        std::fs::write(&tmp_path, toml_content).expect("Failed to write TOML file");
+
+        let config = Config::from_file(&tmp_path).expect("Failed to read config from file");
+
+        assert_eq!(
+            config.headers(),
+            vec![
+                "Authorization: Bearer YOUR_TOKEN",
+                "Content-Type: application/json"
+            ]
+        );
+        assert_eq!(config.indent(), 4);
+    }
+    #[test]
+    fn test_missing_values_defaults() {
+        let toml_content = r#""#;
+
+        let config: Config = toml::from_str(toml_content).expect("Failed to parse empty TOML");
+
+        assert_eq!(config.headers(), Vec::<String>::new());
+        assert_eq!(config.indent(), 2);
+    }
+
+    #[test]
+    fn test_from_file_function() {
+        let toml_content = r#"
+            [default]
+            headers = ["User", "Email"]
+            indent = 3
+        "#;
+
+        let tmp_dir = env::temp_dir();
+        let file_path = tmp_dir.join("test_config.toml");
+
+        write(&file_path, toml_content).expect("Failed to write temp TOML");
+
+        let config = Config::from_file(&file_path).expect("Failed to read config");
+
+        assert_eq!(config.headers(), vec!["User", "Email"]);
+        assert_eq!(config.indent(), 3);
+    }
+}
diff --git a/main/Cargo.toml b/main/Cargo.toml
new file mode 100644
index 0000000..e91ddbf
--- /dev/null
+++ b/main/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "pdat"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+clap = {version = "4.5.48", features = ["derive"] }
+colored = "3.0.0"
+reqwest = {version = "0.12.23", features = ["json"] }
+serde_json = {version = "1.0.145"}
+tokio = {version = "1.47.1", features = ["full"]}
+toml = "0.9.7"
+
+
+config = { path = "../config" }
diff --git a/main/src/main.rs b/main/src/main.rs
new file mode 100644
index 0000000..0604673
--- /dev/null
+++ b/main/src/main.rs
@@ -0,0 +1,185 @@
+use clap::Parser;
+use colored::*;
+use config::Config;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
+use serde_json::Value;
+use std::process;
+
+#[derive(Parser)]
+#[command(author, version, about)]
+struct Args {
+    method: String,
+    url: String,
+    #[arg(short = 'H', long)]
+    header: Vec<String>,
+    #[arg(short = 'd', long)]
+    data: Option<String>,
+    #[arg(short = 'c', long)]
+    config: Option<String>,
+    #[arg(long)]
+    indent: Option<usize>,
+}
+
+fn print_colored_json(value: &Value, indent_level: usize, indent_spaces: usize) {
+    let indent = " ".repeat(indent_spaces * indent_level);
+
+    match value {
+        Value::Object(map) => {
+            println!("{}{}", indent, "{".bright_blue());
+            for (key, val) in map {
+                print!(
+                    "{}{}: ",
+                    " ".repeat(indent_spaces * (indent_level + 1)),
+                    key.bright_cyan()
+                );
+                print_colored_json(val, indent_level + 1, indent_spaces);
+            }
+            println!("{}{}", indent, "}".bright_blue());
+        }
+        Value::Array(arr) => {
+            println!("{}{}", indent, "[".bright_blue());
+            for val in arr {
+                print_colored_json(val, indent_level + 1, indent_spaces);
+            }
+            println!("{}{}", indent, "]".bright_blue());
+        }
+        Value::String(s) => println!("{}{}", indent, format!("\"{}\"", s).bright_yellow()),
+        Value::Number(n) => println!("{}{}", indent, n.to_string().bright_magenta()),
+        Value::Bool(b) => println!("{}{}", indent, b.to_string().bright_green()),
+        Value::Null => println!("{}{}", indent, "null".bright_black()),
+    }
+}
+
+fn colorize_status(status_code: u16) -> ColoredString {
+    match status_code {
+        100..=199 => status_code.to_string().bright_blue(),
+        200..=299 => status_code.to_string().green(),
+        300..=399 => status_code.to_string().cyan(),
+        400..=499 => status_code.to_string().yellow(),
+        500..=599 => status_code.to_string().red(),
+        _ => status_code.to_string().normal(),
+    }
+}
+
+fn build_request(
+    client: &reqwest::Client,
+    method: &str,
+    url: &str,
+    headers: HeaderMap,
+) -> Result<reqwest::RequestBuilder, String> {
+    let method = method.to_uppercase();
+    let builder = match method.as_str() {
+        "GET" => Ok(client.get(url)),
+        "POST" => Ok(client.post(url)),
+        "PUT" => Ok(client.put(url)),
+        "DELETE" => Ok(client.delete(url)),
+        "PATCH" => Ok(client.patch(url)),
+        "OPTIONS" => Ok(client.request(reqwest::Method::OPTIONS, url)),
+        "HEAD" => Ok(client.head(url)),
+        other => Err(format!("Unsupported HTTP method: {}", other)),
+    }?;
+    Ok(builder.headers(headers))
+}
+
+#[tokio::main]
+async fn main() {
+    let args = Args::parse();
+    let client = reqwest::Client::new();
+
+    let config = match args.config.as_ref().map(|p| Config::from_file(p)) {
+        Some(Ok(cfg)) => Some(cfg),
+        Some(Err(e)) => {
+            eprintln!("{}: Failed to load config: {}", "Error".red(), e);
+            process::exit(1);
+        }
+        None => None,
+    };
+
+    let mut headers = HeaderMap::new();
+
+    if let Some(cfg) = &config {
+        for header_str in cfg.headers() {
+            match header_str.split_once(':') {
+                Some((key, value)) => {
+                    if let (Ok(k), Ok(v)) = (
+                        HeaderName::from_bytes(key.trim().as_bytes()),
+                        HeaderValue::from_str(value.trim()),
+                    ) {
+                        headers.insert(k, v);
+                    }
+                }
+                None => eprintln!(
+                    "{}: Invalid header format in config: {}",
+                    "Warning".yellow(),
+                    header_str
+                ),
+            }
+        }
+    }
+
+    for header_str in &args.header {
+        match header_str.split_once(':') {
+            Some((key, value)) => {
+                if let (Ok(k), Ok(v)) = (
+                    HeaderName::from_bytes(key.trim().as_bytes()),
+                    HeaderValue::from_str(value.trim()),
+                ) {
+                    headers.insert(k, v);
+                }
+            }
+            None => eprintln!(
+                "{}: Invalid header format in CLI: {}",
+                "Warning".yellow(),
+                header_str
+            ),
+        }
+    }
+
+    let indent_spaces = args
+        .indent
+        .or_else(|| config.as_ref().map(|c| c.indent()))
+        .unwrap_or(2);
+
+    let mut request_builder = match build_request(&client, &args.method, &args.url, headers) {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("{}: {}", "Error".red(), e);
+            process::exit(1);
+        }
+    };
+
+    if let Some(json_data) = args.data {
+        match serde_json::from_str::<Value>(&json_data) {
+            Ok(json_value) => request_builder = request_builder.json(&json_value),
+            Err(e) => {
+                eprintln!("{}: Invalid JSON body: {}", "Error".red(), e);
+                process::exit(1);
+            }
+        }
+    }
+
+    let response = match request_builder.send().await {
+        Ok(resp) => resp,
+        Err(e) => {
+            eprintln!("{}: Request failed: {}", "Error".red(), e);
+            process::exit(1);
+        }
+    };
+
+    let status_code = response.status().as_u16();
+    println!("Status: {}", colorize_status(status_code));
+
+    let response_text = match response.text().await {
+        Ok(t) => t,
+        Err(e) => {
+            eprintln!("{}: Failed to read response body: {}", "Error".red(), e);
+            process::exit(1);
+        }
+    };
+
+    if let Ok(json_value) = serde_json::from_str::<Value>(&response_text) {
+        print_colored_json(&json_value, 0, indent_spaces);
+    } else {
+        println!("{}", response_text);
+    }
+}