extract shared yaak send flow and wire CLI

crates-cli/yaak-cli/Cargo.toml

@@ -16,6 +16,7 @@ log = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+yaak = { workspace = true }
 yaak-crypto = { workspace = true }
 yaak-http = { workspace = true }
 yaak-models = { workspace = true }

crates-cli/yaak-cli/src/commands/request.rs

@@ -5,19 +5,13 @@ use crate::commands::json::{
     validate_create_id,
 };
 use crate::context::CliContext;
-use log::info;
-use serde_json::Value;
-use std::collections::BTreeMap;
 use tokio::sync::mpsc;
-use yaak_http::path_placeholders::apply_path_placeholders;
-use yaak_http::sender::{HttpSender, ReqwestSender};
-use yaak_http::types::{SendableHttpRequest, SendableHttpRequestOptions};
-use yaak_models::models::{Environment, HttpRequest, HttpRequestHeader, HttpUrlParameter};
-use yaak_models::render::make_vars_hashmap;
+use yaak::send::{SendHttpRequestByIdParams, send_http_request_by_id};
+use yaak_http::types::SendableHttpRequestOptions;
+use yaak_models::models::HttpRequest;
 use yaak_models::util::UpdateSource;
 use yaak_plugins::events::{PluginContext, RenderPurpose};
 use yaak_plugins::template_callback::PluginTemplateCallback;
-use yaak_templates::{RenderOptions, parse_and_render, render_json_value_raw};
 
 pub async fn run(
     ctx: &CliContext,
@@ -179,11 +173,6 @@ pub async fn send_request_by_id(
     let request =
         ctx.db().get_http_request(request_id).map_err(|e| format!("Failed to get request: {e}"))?;
 
-    let environment_chain = ctx
-        .db()
-        .resolve_environments(&request.workspace_id, request.folder_id.as_deref(), environment)
-        .map_err(|e| format!("Failed to resolve environments: {e}"))?;
-
     let plugin_context = PluginContext::new(None, Some(request.workspace_id.clone()));
     let template_callback = PluginTemplateCallback::new(
         ctx.plugin_manager(),
@@ -192,147 +181,49 @@ pub async fn send_request_by_id(
         RenderPurpose::Send,
     );
 
-    let rendered_request = render_http_request(
-        &request,
-        environment_chain,
-        &template_callback,
-        &RenderOptions::throw(),
-    )
-    .await
-    .map_err(|e| format!("Failed to render request templates: {e}"))?;
-
-    if verbose {
-        println!("> {} {}", rendered_request.method, rendered_request.url);
-    }
-
-    let sendable = SendableHttpRequest::from_http_request(
-        &rendered_request,
-        SendableHttpRequestOptions::default(),
-    )
-    .await
-    .map_err(|e| format!("Failed to build request: {e}"))?;
-
     let (event_tx, mut event_rx) = mpsc::channel(100);
-
-    let verbose_handle = if verbose {
-        Some(tokio::spawn(async move {
-            while let Some(event) = event_rx.recv().await {
+    let event_handle = tokio::spawn(async move {
+        while let Some(event) = event_rx.recv().await {
+            if verbose {
                 println!("{}", event);
             }
-        }))
-    } else {
-        tokio::spawn(async move { while event_rx.recv().await.is_some() {} });
-        None
-    };
+        }
+    });
+    let response_dir = ctx.data_dir().join("responses");
 
-    let sender = ReqwestSender::new().map_err(|e| format!("Failed to create HTTP client: {e}"))?;
-    let response = sender
-        .send(sendable, event_tx)
-        .await
-        .map_err(|e| format!("Failed to send request: {e}"))?;
+    let result = send_http_request_by_id(SendHttpRequestByIdParams {
+        query_manager: ctx.query_manager(),
+        blob_manager: ctx.blob_manager(),
+        request_id,
+        environment_id: environment,
+        template_callback: &template_callback,
+        send_options: SendableHttpRequestOptions::default(),
+        update_source: UpdateSource::Sync,
+        response_dir: &response_dir,
+        persist_events: true,
+        emit_events_to: Some(event_tx),
+    })
+    .await;
 
-    if let Some(handle) = verbose_handle {
-        let _ = handle.await;
-    }
+    let _ = event_handle.await;
+    let result = result.map_err(|e| e.to_string())?;
 
     if verbose {
         println!();
     }
-    println!("HTTP {} {}", response.status, response.status_reason.as_deref().unwrap_or(""));
-
+    println!(
+        "HTTP {} {}",
+        result.response.status,
+        result.response.status_reason.as_deref().unwrap_or("")
+    );
     if verbose {
-        for (name, value) in &response.headers {
-            println!("{}: {}", name, value);
+        for header in &result.response.headers {
+            println!("{}: {}", header.name, header.value);
         }
         println!();
     }
-
-    let (body, _stats) =
-        response.text().await.map_err(|e| format!("Failed to read response body: {e}"))?;
+    let body = String::from_utf8(result.response_body)
+        .map_err(|e| format!("Failed to read response body: {e}"))?;
     println!("{}", body);
     Ok(())
 }
-
-/// Render an HTTP request with template variables and plugin functions.
-async fn render_http_request(
-    request: &HttpRequest,
-    environment_chain: Vec<Environment>,
-    callback: &PluginTemplateCallback,
-    options: &RenderOptions,
-) -> yaak_templates::error::Result<HttpRequest> {
-    let vars = &make_vars_hashmap(environment_chain);
-
-    let mut url_parameters = Vec::new();
-    for parameter in request.url_parameters.clone() {
-        if !parameter.enabled {
-            continue;
-        }
-
-        url_parameters.push(HttpUrlParameter {
-            enabled: parameter.enabled,
-            name: parse_and_render(parameter.name.as_str(), vars, callback, options).await?,
-            value: parse_and_render(parameter.value.as_str(), vars, callback, options).await?,
-            id: parameter.id,
-        })
-    }
-
-    let mut headers = Vec::new();
-    for header in request.headers.clone() {
-        if !header.enabled {
-            continue;
-        }
-
-        headers.push(HttpRequestHeader {
-            enabled: header.enabled,
-            name: parse_and_render(header.name.as_str(), vars, callback, options).await?,
-            value: parse_and_render(header.value.as_str(), vars, callback, options).await?,
-            id: header.id,
-        })
-    }
-
-    let mut body = BTreeMap::new();
-    for (key, value) in request.body.clone() {
-        body.insert(key, render_json_value_raw(value, vars, callback, options).await?);
-    }
-
-    let authentication = {
-        let mut disabled = false;
-        let mut auth = BTreeMap::new();
-
-        match request.authentication.get("disabled") {
-            Some(Value::Bool(true)) => {
-                disabled = true;
-            }
-            Some(Value::String(template)) => {
-                disabled = parse_and_render(template.as_str(), vars, callback, options)
-                    .await
-                    .unwrap_or_default()
-                    .is_empty();
-                info!(
-                    "Rendering authentication.disabled as a template: {disabled} from \"{template}\""
-                );
-            }
-            _ => {}
-        }
-
-        if disabled {
-            auth.insert("disabled".to_string(), Value::Bool(true));
-        } else {
-            for (key, value) in request.authentication.clone() {
-                if key == "disabled" {
-                    auth.insert(key, Value::Bool(false));
-                } else {
-                    auth.insert(key, render_json_value_raw(value, vars, callback, options).await?);
-                }
-            }
-        }
-
-        auth
-    };
-
-    let url = parse_and_render(request.url.clone().as_str(), vars, callback, options).await?;
-
-    let (url, url_parameters) = apply_path_placeholders(&url, &url_parameters);
-
-    Ok(HttpRequest { url, url_parameters, headers, body, authentication, ..request.to_owned() })
-}

crates-cli/yaak-cli/src/context.rs

@@ -1,13 +1,16 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use yaak_crypto::manager::EncryptionManager;
+use yaak_models::blob_manager::BlobManager;
 use yaak_models::db_context::DbContext;
 use yaak_models::query_manager::QueryManager;
 use yaak_plugins::events::PluginContext;
 use yaak_plugins::manager::PluginManager;
 
 pub struct CliContext {
+    data_dir: PathBuf,
     query_manager: QueryManager,
+    blob_manager: BlobManager,
     pub encryption_manager: Arc<EncryptionManager>,
     plugin_manager: Option<Arc<PluginManager>>,
 }
@@ -17,9 +20,8 @@ impl CliContext {
         let db_path = data_dir.join("db.sqlite");
         let blob_path = data_dir.join("blobs.sqlite");
 
-        let (query_manager, _blob_manager, _rx) =
-            yaak_models::init_standalone(&db_path, &blob_path)
-                .expect("Failed to initialize database");
+        let (query_manager, blob_manager, _rx) = yaak_models::init_standalone(&db_path, &blob_path)
+            .expect("Failed to initialize database");
 
         let encryption_manager = Arc::new(EncryptionManager::new(query_manager.clone(), app_id));
 
@@ -63,13 +65,25 @@ impl CliContext {
             None
         };
 
-        Self { query_manager, encryption_manager, plugin_manager }
+        Self { data_dir, query_manager, blob_manager, encryption_manager, plugin_manager }
+    }
+
+    pub fn data_dir(&self) -> &Path {
+        &self.data_dir
     }
 
     pub fn db(&self) -> DbContext<'_> {
         self.query_manager.connect()
     }
 
+    pub fn query_manager(&self) -> &QueryManager {
+        &self.query_manager
+    }
+
+    pub fn blob_manager(&self) -> &BlobManager {
+        &self.blob_manager
+    }
+
     pub fn plugin_manager(&self) -> Arc<PluginManager> {
         self.plugin_manager.clone().expect("Plugin manager was not initialized for this command")
     }

crates-cli/yaak-cli/tests/common/http_server.rs

@@ -0,0 +1,42 @@
+use std::io::{Read, Write};
+use std::net::TcpListener;
+use std::thread;
+
+pub struct TestHttpServer {
+    pub url: String,
+    handle: Option<thread::JoinHandle<()>>,
+}
+
+impl TestHttpServer {
+    pub fn spawn_ok(body: &'static str) -> Self {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind test HTTP server");
+        let addr = listener.local_addr().expect("Failed to get local addr");
+        let url = format!("http://{addr}/test");
+        let body_bytes = body.as_bytes().to_vec();
+
+        let handle = thread::spawn(move || {
+            if let Ok((mut stream, _)) = listener.accept() {
+                let mut request_buf = [0u8; 4096];
+                let _ = stream.read(&mut request_buf);
+
+                let response = format!(
+                    "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+                    body_bytes.len()
+                );
+                let _ = stream.write_all(response.as_bytes());
+                let _ = stream.write_all(&body_bytes);
+                let _ = stream.flush();
+            }
+        });
+
+        Self { url, handle: Some(handle) }
+    }
+}
+
+impl Drop for TestHttpServer {
+    fn drop(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            let _ = handle.join();
+        }
+    }
+}

crates-cli/yaak-cli/tests/common/mod.rs

@@ -1,5 +1,7 @@
 #![allow(dead_code)]
 
+pub mod http_server;
+
 use assert_cmd::Command;
 use assert_cmd::cargo::cargo_bin_cmd;
 use std::path::Path;

crates-cli/yaak-cli/tests/request_commands.rs

@@ -1,8 +1,10 @@
 mod common;
 
+use common::http_server::TestHttpServer;
 use common::{cli_cmd, parse_created_id, query_manager, seed_request, seed_workspace};
 use predicates::str::contains;
 use tempfile::TempDir;
+use yaak_models::models::HttpResponseState;
 
 #[test]
 fn show_and_delete_yes_round_trip() {
@@ -105,3 +107,53 @@ fn update_requires_id_in_json_payload() {
         .failure()
         .stderr(contains("request update requires a non-empty \"id\" field"));
 }
+
+#[test]
+fn request_send_persists_response_body_and_events() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    let data_dir = temp_dir.path();
+    seed_workspace(data_dir, "wk_test");
+
+    let server = TestHttpServer::spawn_ok("hello from integration test");
+
+    let create_assert = cli_cmd(data_dir)
+        .args([
+            "request",
+            "create",
+            "wk_test",
+            "--name",
+            "Send Test",
+            "--url",
+            &server.url,
+        ])
+        .assert()
+        .success();
+    let request_id = parse_created_id(&create_assert.get_output().stdout, "request create");
+
+    cli_cmd(data_dir)
+        .args(["request", "send", &request_id])
+        .assert()
+        .success()
+        .stdout(contains("HTTP 200 OK"))
+        .stdout(contains("hello from integration test"));
+
+    let qm = query_manager(data_dir);
+    let db = qm.connect();
+    let responses =
+        db.list_http_responses_for_request(&request_id, None).expect("Failed to load responses");
+    assert_eq!(responses.len(), 1, "expected exactly one persisted response");
+
+    let response = &responses[0];
+    assert_eq!(response.status, 200);
+    assert!(matches!(response.state, HttpResponseState::Closed));
+    assert!(response.error.is_none());
+
+    let body_path =
+        response.body_path.as_ref().expect("expected persisted response body path").to_string();
+    let body = std::fs::read_to_string(&body_path).expect("Failed to read response body file");
+    assert_eq!(body, "hello from integration test");
+
+    let events =
+        db.list_http_response_events(&response.id).expect("Failed to load response events");
+    assert!(!events.is_empty(), "expected at least one persisted response event");
+}