Move a request's versions with it when it changes workspace

A workspace delete removes versions by workspace_id, but a request
moved to another workspace kept versions tagged with the old one, so
deleting the old workspace deleted versions that responses in the new
workspace still pointed at.

The workspace cascade has to stay: a workspace delete removes its
requests in bulk and never runs each request's own version cascade.
Instead, every request upsert retags that request's versions to its
current workspace, one indexed UPDATE that changes no rows unless the
request moved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Gregory SchierandClaude Opus 5.5 authored and Stetta task tk_mw563e1dcqtc4sqh committed 2026-11-06 14:30:47 -07:00
1 parent 17e719a646
commit 7be5b49b0b
4 files changed
+82 -3

No files matched your search

@@ -146,6 +146,8 @@ impl<'a> WriteDb<'a> {
grpc_request: &GrpcRequest,
source: &UpdateSource,
) -> Result<GrpcRequest> {
self.upsert(grpc_request, source)
let request = self.upsert(grpc_request, source)?;
self.move_model_versions_to_workspace(&request.id, &request.workspace_id)?;
Ok(request)
}
}
@@ -178,7 +178,9 @@ impl<'a> WriteDb<'a> {
http_request: &HttpRequest,
source: &UpdateSource,
) -> Result<HttpRequest> {
self.upsert(http_request, source)
let request = self.upsert(http_request, source)?;
self.move_model_versions_to_workspace(&request.id, &request.workspace_id)?;
Ok(request)
}
}
@@ -189,6 +189,23 @@ impl<'a> WriteDb<'a> {
self.delete_many_untracked::<ModelVersion>(ModelVersionIden::ModelId, model_id)
}
/// Keep a request's versions in the workspace the request is in.
///
/// A workspace delete removes its versions by workspace, so a request moved
/// to another workspace must take its history with it, or deleting the old
/// workspace would delete versions that responses in the new one point at.
/// Called on every request write; when nothing moved it changes no rows.
pub(crate) fn move_model_versions_to_workspace(
&self,
model_id: &str,
workspace_id: &str,
) -> Result<usize> {
Ok(self.conn().execute(
"UPDATE model_versions SET workspace_id = ?2 WHERE model_id = ?1 AND workspace_id != ?2",
rusqlite::params![model_id, workspace_id],
)?)
}
/// Drop the versions a request no longer needs.
///
/// A version referenced by a response outlives retention entirely — the
@@ -551,4 +568,60 @@ mod tests {
assert!(db.list_model_versions(&request.id).unwrap().is_empty());
});
}
#[test]
fn deleting_a_workspace_deletes_its_requests_versions() {
with_db(|db, blobs| {
let (workspace, request) = seed(db);
make_versions(db, &request, 2);
db.delete_workspace(&workspace, &source(), blobs).unwrap();
assert!(db.list_model_versions(&request.id).unwrap().is_empty());
});
}
/// A moved request takes its history along: deleting the workspace it
/// left must not delete versions its responses in the new one point at.
#[test]
fn a_moved_request_keeps_its_versions_when_its_old_workspace_is_deleted() {
with_db(|db, blobs| {
let (old_workspace, request) = seed(db);
let version = snapshot(db, &request.id, ModelVersionReason::Send);
let new_workspace = db
.upsert_workspace(
&Workspace { name: "Elsewhere".to_string(), ..Default::default() },
&source(),
)
.unwrap();
let moved = db
.upsert_http_request(
&HttpRequest { workspace_id: new_workspace.id.clone(), ..request.clone() },
&source(),
)
.unwrap();
// Moving changes no content, so a send from the new workspace
// reuses the version, and a response there points at it
let sent = snapshot(db, &moved.id, ModelVersionReason::Send);
assert_eq!(sent.id, version.id);
db.upsert_http_response(
&HttpResponse {
request_id: moved.id.clone(),
workspace_id: new_workspace.id.clone(),
version_id: Some(version.id.clone()),
..Default::default()
},
&source(),
blobs,
)
.unwrap();
db.delete_workspace(&old_workspace, &source(), blobs).unwrap();
let survived = db.get_model_version(&version.id).expect("the version must survive");
assert_eq!(survived.workspace_id, new_workspace.id);
assert!(db.request_matches_version(&survived).unwrap());
});
}
}
@@ -168,6 +168,8 @@ impl<'a> WriteDb<'a> {
websocket_request: &WebsocketRequest,
source: &UpdateSource,
) -> Result<WebsocketRequest> {
self.upsert(websocket_request, source)
let request = self.upsert(websocket_request, source)?;
self.move_model_versions_to_workspace(&request.id, &request.workspace_id)?;
Ok(request)
}
}