Share the send settings and their timeline lines across desktop, tab and proxy

crates-server/yaak-send-proxy/src/send.rs

@@ -6,7 +6,7 @@
 //! would write to its database is written to the reply stream instead, and the tab stores it.
 
 use crate::guard::{DestinationPolicy, GuardedSender};
-use crate::wire::{Frame, SendRequest, WireHeader};
+use crate::wire::{Frame, SendRequest};
 use base64::Engine;
 use bytes::Bytes;
 use log::{info, warn};
@@ -21,6 +21,7 @@ use yaak_http::cookies::CookieStore;
 use yaak_http::sender::{HttpResponseEvent, ReqwestSender};
 use yaak_http::transaction::HttpTransaction;
 use yaak_http::types::{SendableHttpRequest, SendableHttpRequestOptions};
+use yaak_models::models::HttpResponseHeader;
 
 /// How many frames may sit unread by the client before body reading pauses. Backpressure, so a
 /// slow tab slows the upstream read rather than filling memory.
@@ -115,7 +116,7 @@ pub async fn prepare(limits: Arc<SendLimits>, send: SendRequest) -> Result<Prepa
 pub struct PreparedSend {
     limits: Arc<SendLimits>,
     sendable: SendableHttpRequest,
-    settings: crate::wire::SendSettings,
+    settings: yaak_models::models::HttpSendSettings,
     cookies: Option<Vec<yaak_models::models::Cookie>>,
     timeout: Duration,
     timeout_capped: bool,
@@ -331,10 +332,10 @@ struct DoneStats {
     content_length_compressed: u64,
 }
 
-fn to_wire_headers(headers: &[(String, String)]) -> Vec<WireHeader> {
+fn to_wire_headers(headers: &[(String, String)]) -> Vec<HttpResponseHeader> {
     headers
         .iter()
-        .map(|(name, value)| WireHeader { name: name.clone(), value: value.clone() })
+        .map(|(name, value)| HttpResponseHeader { name: name.clone(), value: value.clone() })
         .collect()
 }
 

crates-server/yaak-send-proxy/src/wire.rs

@@ -11,7 +11,9 @@
 //! back.
 
 use serde::{Deserialize, Serialize};
-use yaak_models::models::{Cookie, HttpRequest, HttpResponseEventData};
+use yaak_models::models::{
+    Cookie, HttpRequest, HttpResponseEventData, HttpResponseHeader, HttpSendSettings,
+};
 
 /// The body of `POST /v1/http/send`.
 #[derive(Deserialize, Debug)]
@@ -21,32 +23,14 @@ pub struct SendRequest {
     /// rendered by the tab. The proxy builds the URL, headers and body from it exactly the way
     /// the desktop does after rendering.
     pub request: HttpRequest,
-    pub settings: SendSettings,
+    /// The resolved settings, values only. Where they came from is the tab's to record in
+    /// its timeline; the proxy only needs to obey them.
+    pub settings: HttpSendSettings,
     /// The cookies to start with. `None` means no jar at all: nothing sent, nothing kept.
     #[serde(default)]
     pub cookies: Option<Vec<Cookie>>,
 }
 
-/// The resolved send settings, values only. Where they came from (request, folder, workspace)
-/// is the tab's to record in its timeline; the proxy only needs to obey them.
-#[derive(Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct SendSettings {
-    pub validate_certificates: bool,
-    pub follow_redirects: bool,
-    /// Milliseconds. Zero or negative means "no timeout", which the proxy caps regardless.
-    pub timeout_ms: i64,
-    pub send_cookies: bool,
-    pub store_cookies: bool,
-}
-
-#[derive(Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct WireHeader {
-    pub name: String,
-    pub value: String,
-}
-
 /// One line of the reply stream. Tags are snake_case like the timeline event tags; fields are
 /// camelCase like every model the tab stores.
 #[derive(Serialize, Debug)]
@@ -68,9 +52,9 @@ pub enum Frame {
         url: String,
         remote_addr: Option<String>,
         version: Option<String>,
-        headers: Vec<WireHeader>,
+        headers: Vec<HttpResponseHeader>,
         /// The headers that were actually sent on the final hop, cookies and all.
-        request_headers: Vec<WireHeader>,
+        request_headers: Vec<HttpResponseHeader>,
         /// `Content-Length` as declared by the server, if it declared one.
         content_length: Option<u64>,
         /// Milliseconds from the start of the send to the response head.