andras/reconcile
1
0
Fork 0
Code Issues Pull requests 5 Projects Releases Packages Wiki Activity Actions

Add back document ids

Browse source
This commit is contained in:
Andras Schmelczer 2024-12-15 11:45:53 +00:00
parent cd46acd130
commit c567cec656
No known key found for this signature in database
GPG key ID: FC8F2C3D3D1A718C
9 changed files with 293 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

119
backend/sync_server/src/server/update_document.rs
View file

@ -15,7 +15,7 @@ use sync_lib::{base64_to_bytes, merge};
use super::{auth::auth, requests::UpdateDocumentVersion};
use crate::{
app_state::AppState,
database::models::{DocumentVersion, StoredDocumentVersion, VaultId},
database::models::{DocumentId, DocumentVersion, StoredDocumentVersion, VaultId},
errors::{client_error, not_found_error, server_error, SyncServerError},
};
@ -23,7 +23,7 @@ use crate::{
#[derive(Deserialize, JsonSchema)]
pub struct PathParams {
vault_id: VaultId,
relative_path: String,
document_id: DocumentId,
}
#[axum::debug_handler]
@ -31,35 +31,26 @@ pub async fn update_document(
TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
Path(PathParams {
vault_id,
relative_path,
document_id,
}): Path<PathParams>,
State(state): State<AppState>,
Json(request): Json<UpdateDocumentVersion>,
) -> Result<Json<DocumentVersion>, SyncServerError> {
auth(&state, auth_header.token())?;
let parent_content = if let Some(parent_version_id) = request.parent_version_id {
state
.database
.get_document_version(&vault_id, parent_version_id, None)
.await
.map_err(server_error)?
.map(Ok)
.unwrap_or_else(|| {
Err(not_found_error(anyhow!(
"Parent version with id `{}` not found",
parent_version_id
)))
})
.map(|version| version.content)
} else {
// the empty string is the first common parent of the two documents
Ok(Vec::default())
}?;
let content_bytes = base64_to_bytes(&request.content_base64)
.context("Failed to decode base64 content in request")
.map_err(client_error)?;
// No need for a transaction as document versions are immutable
let parent_document = state
.database
.get_document_version(&vault_id, request.parent_version_id, None)
.await
.map_err(server_error)?
.map(Ok)
.unwrap_or_else(|| {
Err(not_found_error(anyhow!(
"Parent version with id `{}` not found",
request.parent_version_id
)))
})?;
let mut transaction = state
.database
@ -67,7 +58,7 @@ pub async fn update_document(
.await
.map_err(server_error)?;
let mut last_update_id = state
let last_update_id = state
.database
.get_max_update_id_in_vault(&vault_id, Some(&mut transaction))
.await
@ -75,57 +66,59 @@ pub async fn update_document(
let latest_version = state
.database
.get_latest_document(&vault_id, &relative_path, Some(&mut transaction))
.get_latest_document(&vault_id, &document_id, Some(&mut transaction))
.await
.map_err(server_error)?;
.map_err(server_error)?
.map(Ok)
.unwrap_or_else(|| {
Err(not_found_error(anyhow!(
"Document with id `{document_id}` not found",
)))
})?;
if let Some(latest) = latest_version.as_ref() {
if content_bytes == latest.content && relative_path == latest.relative_path {
info!("Document content is the same as the latest version, skipping update");
transaction
.rollback()
.await
.context("Failed to rollback transaction")
.map_err(server_error)?;
let content_bytes = base64_to_bytes(&request.content_base64)
.context("Failed to decode base64 content in request")
.map_err(client_error)?;
return Ok(Json(latest.clone().into()));
} else if relative_path != latest.relative_path {
let delete_at_previous_path = StoredDocumentVersion {
vault_id: vault_id.clone(),
vault_update_id: last_update_id + 1,
relative_path: latest.relative_path.clone(),
content: vec![],
created_date: request.created_date,
updated_date: chrono::Utc::now(),
is_deleted: true,
};
// Return the latest version if the content and path are the same as the latest
// version
if content_bytes == latest_version.content
&& request.relative_path == latest_version.relative_path
{
info!("Document content is the same as the latest version, skipping update");
transaction
.rollback()
.await
.context("Failed to rollback transaction")
.map_err(server_error)?;
last_update_id += 1;
state
.database
.insert_document_version(&delete_at_previous_path, Some(&mut transaction))
.await
.map_err(server_error)?;
}
return Ok(Json(latest_version.into()));
}
let latest_version_content = latest_version
.map(|v| v.content)
.unwrap_or_else(Vec::default);
let merged_content = merge(
&parent_document.content,
&latest_version.content,
&content_bytes,
)
.context("Failed to decode bytes as UTF-8")
.map_err(client_error)?;
let merged_content = merge(&parent_content, &latest_version_content, &content_bytes)
.context("Failed to decode bytes as UTF-8")
.map_err(client_error)?;
// We can only update the relative path if we're the first one to do so
let new_relative_path = if parent_document.relative_path == latest_version.relative_path {
request.relative_path.clone()
} else {
latest_version.relative_path.clone()
};
let new_version = StoredDocumentVersion {
vault_id,
document_id,
vault_update_id: last_update_id + 1,
relative_path,
relative_path: new_relative_path,
content: merged_content,
created_date: request.created_date,
updated_date: chrono::Utc::now(),
is_deleted: false,
is_deleted: parent_document.is_deleted,
};
state