Add back document ids

backend/sync_server/src/server/create_document.rs

@@ -0,0 +1,109 @@
+use anyhow::Context;
+use axum::{
+    extract::{Path, State},
+    Json,
+};
+use axum_extra::{
+    headers::{authorization::Bearer, Authorization},
+    TypedHeader,
+};
+use schemars::JsonSchema;
+use serde::Deserialize;
+use sync_lib::{base64_to_bytes, merge};
+
+use super::{auth::auth, requests::CreateDocumentVersion};
+use crate::{
+    app_state::AppState,
+    database::models::{DocumentVersion, StoredDocumentVersion, VaultId},
+    errors::{client_error, server_error, SyncServerError},
+};
+
+// This is required for aide to infer the path parameter types and names
+#[derive(Deserialize, JsonSchema)]
+pub struct PathParams {
+    vault_id: VaultId,
+}
+
+/// Create a new document in case a document with the same doesn't exist
+/// already. If a document with the same path exists, a new version is created
+/// with their content merged.
+#[axum::debug_handler]
+pub async fn create_document(
+    TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
+    Path(PathParams { vault_id }): Path<PathParams>,
+    State(state): State<AppState>,
+    Json(request): Json<CreateDocumentVersion>,
+) -> Result<Json<DocumentVersion>, SyncServerError> {
+    auth(&state, auth_header.token())?;
+
+    let mut transaction = state
+        .database
+        .create_transaction()
+        .await
+        .map_err(server_error)?;
+
+    let last_update_id = state
+        .database
+        .get_max_update_id_in_vault(&vault_id, Some(&mut transaction))
+        .await
+        .map_err(server_error)?;
+
+    let maybe_existing_version = state
+        .database
+        .get_latest_document_by_path(&vault_id, &request.relative_path, Some(&mut transaction))
+        .await
+        .map_err(server_error)?
+        .and_then(|doc| if doc.is_deleted { None } else { Some(doc) });
+
+    let new_version = if let Some(existing_version) = maybe_existing_version {
+        let content_bytes = base64_to_bytes(&request.content_base64)
+            .context("Failed to decode base64 content in request")
+            .map_err(client_error)?;
+
+        let merged_content = merge(
+            &[], // the empty string is the first common parent of the two documents,
+            &existing_version.content,
+            &content_bytes,
+        )
+        .context("Failed to decode bytes as UTF-8")
+        .map_err(client_error)?;
+
+        StoredDocumentVersion {
+            vault_id,
+            vault_update_id: last_update_id + 1,
+            relative_path: request.relative_path,
+            document_id: existing_version.document_id,
+            content: merged_content,
+            created_date: request.created_date,
+            updated_date: chrono::Utc::now(),
+            is_deleted: false,
+        }
+    } else {
+        StoredDocumentVersion {
+            vault_id,
+            vault_update_id: last_update_id + 1,
+            document_id: uuid::Uuid::new_v4(),
+            relative_path: request.relative_path,
+            content: base64_to_bytes(&request.content_base64)
+                .context("Cannot convert base64 encoded content to bytes")
+                .map_err(client_error)?,
+            created_date: request.created_date,
+            updated_date: chrono::Utc::now(),
+            is_deleted: false,
+        }
+    };
+
+    state
+        .database
+        .insert_document_version(&new_version, Some(&mut transaction))
+        .await
+        .map_err(server_error)?;
+
+    transaction
+        .commit()
+        .await
+        .context("Failed to commit successful transaction")
+        .map_err(server_error)?;
+
+    Ok(Json(new_version.into()))
+}

backend/sync_server/src/server/delete_document.rs

@@ -13,7 +13,7 @@ use serde::Deserialize;
 use super::{auth::auth, requests::DeleteDocumentVersion};
 use crate::{
     app_state::AppState,
-    database::models::{StoredDocumentVersion, VaultId},
+    database::models::{DocumentId, StoredDocumentVersion, VaultId},
     errors::{server_error, SyncServerError},
 };
 
@@ -21,7 +21,7 @@ use crate::{
 #[derive(Deserialize, JsonSchema)]
 pub struct PathParams {
     vault_id: VaultId,
-    relative_path: String,
+    document_id: DocumentId,
 }
 
 #[axum::debug_handler]
@@ -29,7 +29,7 @@ pub async fn delete_document(
     TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
     Path(PathParams {
         vault_id,
-        relative_path,
+        document_id,
     }): Path<PathParams>,
     State(state): State<AppState>,
     Json(request): Json<DeleteDocumentVersion>,
@@ -51,7 +51,8 @@ pub async fn delete_document(
     let new_version = StoredDocumentVersion {
         vault_id,
         vault_update_id: last_update_id + 1,
-        relative_path,
+        document_id,
+        relative_path: request.relative_path,
         content: vec![],
         created_date: request.created_date,
         updated_date: chrono::Utc::now(),

backend/sync_server/src/server/fetch_latest_document_version.rs

@@ -13,7 +13,7 @@ use serde::Deserialize;
 use super::auth::auth;
 use crate::{
     app_state::AppState,
-    database::models::{DocumentVersion, VaultId},
+    database::models::{DocumentId, DocumentVersion, VaultId},
     errors::{not_found_error, server_error, SyncServerError},
 };
 
@@ -21,7 +21,7 @@ use crate::{
 #[derive(Deserialize, JsonSchema)]
 pub struct PathParams {
     vault_id: VaultId,
-    relative_path: String,
+    document_id: DocumentId,
 }
 
 #[axum::debug_handler]
@@ -29,7 +29,7 @@ pub async fn fetch_latest_document_version(
     TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
     Path(PathParams {
         vault_id,
-        relative_path,
+        document_id,
     }): Path<PathParams>,
     State(state): State<AppState>,
 ) -> Result<Json<DocumentVersion>, SyncServerError> {
@@ -37,14 +37,13 @@ pub async fn fetch_latest_document_version(
 
     let latest_version = state
         .database
-        .get_latest_document(&vault_id, &relative_path, None)
+        .get_latest_document(&vault_id, &document_id, None)
         .await
         .map_err(server_error)?
         .map(Ok)
         .unwrap_or_else(|| {
             Err(not_found_error(anyhow!(
-                "Latest document version of document `{}` not found",
-                relative_path
+                "Document with id `{document_id}` not found",
             )))
         })?;
 

backend/sync_server/src/server/requests.rs

@@ -4,10 +4,19 @@ use serde::{self, Deserialize};
 
 use crate::database::models::VaultUpdateId;
 
+#[derive(Debug, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateDocumentVersion {
+    pub relative_path: String,
+    pub created_date: DateTime<Utc>,
+    pub content_base64: String,
+}
+
 #[derive(Debug, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateDocumentVersion {
-    pub parent_version_id: Option<VaultUpdateId>,
+    pub parent_version_id: VaultUpdateId,
+    pub relative_path: String,
     pub created_date: DateTime<Utc>,
     pub content_base64: String,
 }
@@ -15,5 +24,6 @@ pub struct UpdateDocumentVersion {
 #[derive(Debug, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct DeleteDocumentVersion {
+    pub relative_path: String,
     pub created_date: DateTime<Utc>,
 }

backend/sync_server/src/server/update_document.rs

@@ -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