From 34d0aed906b4865f37bb1e11c1f2b3e1e732c047 Mon Sep 17 00:00:00 2001 From: Gregory Schier Date: Fri, 6 Nov 2026 10:35:24 -0700 Subject: [PATCH] Version the stored request on send, not the one being sent A plugin can send a request it has already rendered, such as the response template function. resolve_send_inputs snapshotted whatever request it was handed, so those versions held rendered values, secrets included, where the user had templates, and a restore would have written the literals back. snapshot_request_for_send now takes a request id and reads the stored row inside its transaction. A request with no id or no stored row gets no version, as a failed snapshot already did. gRPC and WebSocket connect go through the same method, so all three capture the same thing. Co-Authored-By: Claude Opus 5.5 --- crates-tauri/yaak-app-client/src/lib.rs | 4 +- crates-tauri/yaak-app-client/src/ws_ext.rs | 4 +- .../yaak-models/src/queries/model_versions.rs | 26 +++-- crates/yaak/src/send.rs | 97 +++++++++++++++---- 4 files changed, 100 insertions(+), 31 deletions(-) diff --git a/crates-tauri/yaak-app-client/src/lib.rs b/crates-tauri/yaak-app-client/src/lib.rs index 395173558..d2cf1494f 100644 --- a/crates-tauri/yaak-app-client/src/lib.rs +++ b/crates-tauri/yaak-app-client/src/lib.rs @@ -40,7 +40,6 @@ use yaak_models::models::{ CookieJar, Environment, GrpcConnection, GrpcConnectionState, GrpcEvent, GrpcEventType, HttpRequest, HttpResponse, HttpResponseState, Workspace, }; -use yaak_models::queries::any_request::AnyRequest; use yaak_models::util::{BatchUpsertResult, ImportDestination, ImportPlan, UpdateSource}; use yaak_plugins::events::{ Color, ErrorResponse, FilterResponse, InternalEvent, InternalEventPayload, PluginContext, @@ -335,8 +334,7 @@ async fn cmd_grpc_go( let conn = app_handle.with_tx(|tx| { // Capture the stored request, not the rendered one: what a restore should // put back is what the user typed - let version_id = - tx.snapshot_request_for_send(&AnyRequest::GrpcRequest(unrendered_request.clone())); + let version_id = tx.snapshot_request_for_send(&unrendered_request.id); tx.upsert_grpc_connection( &GrpcConnection { workspace_id: request.workspace_id.clone(), diff --git a/crates-tauri/yaak-app-client/src/ws_ext.rs b/crates-tauri/yaak-app-client/src/ws_ext.rs index a8a880cef..a1dae13d5 100644 --- a/crates-tauri/yaak-app-client/src/ws_ext.rs +++ b/crates-tauri/yaak-app-client/src/ws_ext.rs @@ -21,7 +21,6 @@ use yaak_models::models::{ HttpResponseHeader, WebsocketConnection, WebsocketConnectionState, WebsocketEvent, WebsocketEventType, }; -use yaak_models::queries::any_request::AnyRequest; use yaak_models::util::UpdateSource; use yaak_plugins::events::{CallHttpAuthenticationRequest, HttpHeader, RenderPurpose}; use yaak_plugins::template_callback::PluginTemplateCallback; @@ -176,8 +175,7 @@ pub async fn cmd_ws_connect( let connection = app_handle.with_tx(|tx| { // Capture the stored request, not the rendered one: what a restore should // put back is what the user typed - let version_id = - tx.snapshot_request_for_send(&AnyRequest::WebsocketRequest(unrendered_request.clone())); + let version_id = tx.snapshot_request_for_send(&unrendered_request.id); tx.upsert_websocket_connection( &WebsocketConnection { workspace_id: request.workspace_id.clone(), diff --git a/crates/yaak-models/src/queries/model_versions.rs b/crates/yaak-models/src/queries/model_versions.rs index 66e0088a0..b8b443da8 100644 --- a/crates/yaak-models/src/queries/model_versions.rs +++ b/crates/yaak-models/src/queries/model_versions.rs @@ -1,6 +1,6 @@ use crate::client_db::{ClientDb, WriteDb}; use crate::content::content_hash; -use crate::error::Result; +use crate::error::{Error, Result}; use crate::models::{ GrpcRequest, HttpRequest, ModelVersion, ModelVersionIden, ModelVersionReason, UpsertModelInfo, WebsocketRequest, @@ -106,14 +106,28 @@ impl<'a> WriteDb<'a> { /// What every send calls: capture the request, and don't make a fuss. /// + /// Takes an id rather than a request because the request a send holds is + /// not always the stored one: a plugin can send a request it has already + /// rendered, and a version of that would hold literal values, secrets + /// included, where the user wrote templates. The stored row is what a + /// restore should put back, so that is what gets captured. + /// /// A send is not worth failing over history that couldn't be written, and - /// a request with no id is ephemeral and has nothing to version. Either way - /// the response just has no version to offer. - pub fn snapshot_request_for_send(&self, request: &AnyRequest) -> Option { - if request.id().is_empty() { + /// a request with no id or no stored row is ephemeral and has nothing to + /// version. Either way the response just has no version to offer. + pub fn snapshot_request_for_send(&self, request_id: &str) -> Option { + if request_id.is_empty() { return None; } - match self.snapshot_request(request, ModelVersionReason::Send) { + let stored = match self.get_any_request(request_id) { + Ok(stored) => stored, + Err(Error::ModelNotFound(_)) => return None, + Err(err) => { + warn!("Failed to load request to snapshot before send: {err}"); + return None; + } + }; + match self.snapshot_request(&stored, ModelVersionReason::Send) { Ok(version) => Some(version.id), Err(err) => { warn!("Failed to snapshot request before send: {err}"); diff --git a/crates/yaak/src/send.rs b/crates/yaak/src/send.rs index 81841f11b..8a0278399 100644 --- a/crates/yaak/src/send.rs +++ b/crates/yaak/src/send.rs @@ -27,7 +27,6 @@ use yaak_models::models::{ HttpResponseEvent, HttpResponseEventData, HttpResponseHeader, HttpResponseState, ProxySetting, ProxySettingAuth, ResolvedHttpRequestSettings, }; -use yaak_models::queries::any_request::AnyRequest; use yaak_models::query_manager::QueryManager; use yaak_models::render::render_http_request; use yaak_models::util::{UpdateSource, generate_prefixed_id}; @@ -437,28 +436,24 @@ pub fn resolve_send_inputs( client_certificates: settings.client_certificates, }, cookie_store: cookies.map(CookieStore::from_cookies), - // Captured here rather than deeper in the send because this is the last place that - // still holds the *stored* request: further down it has been resolved against its - // folder and workspace and then rendered, and neither of those is what a restore - // should put back. Every host reaches sending through this function — the desktop, - // the CLI, plugin-triggered sends — so every response gets a version without each - // of them remembering to ask for one. - version_id: snapshot_request_for_send(query_manager, request), + // Every host reaches sending through this function — the desktop, the CLI, + // plugin-triggered sends — so every response gets a version without each of them + // remembering to ask for one. The version is of the stored row, not of `request`: + // what a send holds may already be resolved or rendered (a plugin can send a + // request it rendered itself), and neither is what a restore should put back. + version_id: snapshot_request_for_send(query_manager, &request.id), }) } -/// Capture the request in its own transaction. Like the snapshot itself, a failure -/// to get the write connection is not worth failing the send over. -fn snapshot_request_for_send( - query_manager: &QueryManager, - request: &HttpRequest, -) -> Option { +/// Capture the stored request in its own transaction. Like the snapshot itself, a +/// failure to get the write connection is not worth failing the send over. +fn snapshot_request_for_send(query_manager: &QueryManager, request_id: &str) -> Option { + // An unsaved request has nothing to version; don't take the writer for it + if request_id.is_empty() { + return None; + } query_manager - .with_tx(|tx| { - Ok::<_, yaak_models::error::Error>( - tx.snapshot_request_for_send(&AnyRequest::HttpRequest(request.clone())), - ) - }) + .with_tx(|tx| Ok::<_, yaak_models::error::Error>(tx.snapshot_request_for_send(request_id))) .unwrap_or_else(|err| { warn!("Failed to snapshot request before send: {err}"); None @@ -1536,6 +1531,70 @@ mod tests { assert!(!db.request_matches_version(&version).expect("Failed to compare")); } + /// A plugin can send a request it has already rendered. The version must + /// still be of the stored row, templates and all, or a restore would write + /// literal values (secrets included) over what the user typed. + #[tokio::test] + async fn a_send_of_a_rendered_request_versions_the_stored_templates() { + let (query_manager, blob_manager, temp_dir) = seed_send_storage(); + let header = |value: &str| yaak_models::models::HttpRequestHeader { + name: "Authorization".to_string(), + value: value.to_string(), + ..Default::default() + }; + let stored = query_manager + .with_tx(|tx| { + tx.upsert_http_request( + &HttpRequest { + workspace_id: "wk_test".to_string(), + url: "${[ base_url ]}/test".to_string(), + headers: vec![header("Bearer ${[ token ]}")], + ..Default::default() + }, + &UpdateSource::Sync, + ) + }) + .expect("Failed to seed request"); + + let rendered = HttpRequest { + url: "http://localhost/test".to_string(), + headers: vec![header("Bearer s3cret")], + ..stored.clone() + }; + let response = stored_send(&query_manager, &blob_manager, temp_dir.path(), &rendered).await; + + let version_id = response.version_id.expect("a stored request must record a version"); + let version = + query_manager.connect().get_model_version(&version_id).expect("Failed to load version"); + assert_eq!(version.document.get("url").unwrap(), "${[ base_url ]}/test"); + let headers = version.document.get("headers").unwrap().to_string(); + assert!(headers.contains("Bearer ${[ token ]}"), "headers were {headers}"); + assert!(!headers.contains("s3cret"), "a rendered secret reached version history"); + assert!( + query_manager.connect().request_matches_version(&version).unwrap(), + "an untouched request must not look changed", + ); + } + + /// A request with an id but no stored row has nothing to version, and + /// resolving its send must not fail for it. + #[test] + fn resolving_a_send_of_an_unstored_request_records_no_version() { + let (query_manager, _blob_manager, _temp_dir) = seed_send_storage(); + let transient = HttpRequest { + id: "rq_not_stored".to_string(), + workspace_id: "wk_test".to_string(), + url: "http://localhost/test".to_string(), + ..Default::default() + }; + + let inputs = resolve_send_inputs(&query_manager, &transient, None, None) + .expect("Failed to resolve send inputs"); + + assert_eq!(inputs.version_id, None); + assert!(query_manager.connect().list_model_versions("rq_not_stored").unwrap().is_empty()); + } + async fn stored_send( query_manager: &QueryManager, blob_manager: &BlobManager,