andras/vault-link
1
0
Fork 0
Code Issues Pull requests 18 Projects Releases 55 Packages Wiki Activity Actions 1

Replace document_id with relative path

Browse source
This commit is contained in:
Andras Schmelczer 2024-12-14 14:59:29 +00:00
parent 476c0ed672
commit fe7ff5349d
No known key found for this signature in database
GPG key ID: FC8F2C3D3D1A718C
11 changed files with 83 additions and 270 deletions
Download patch file Download diff file Expand all files Collapse all files

106
backend/sync_server/src/server/create_document.rs
View file

@ -1,106 +0,0 @@
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 maybe_existing_version = state
.database
.get_latest_document_version_by_path(
&vault_id,
&request.relative_path,
Some(&mut transaction),
)
.await
.map_err(server_error)?;
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,
document_id: existing_version.document_id,
version_id: existing_version.version_id + 1,
content: merged_content,
created_date: request.created_date,
relative_path: request.relative_path,
updated_date: chrono::Utc::now(),
is_deleted: false,
}
} else {
StoredDocumentVersion {
vault_id,
document_id: uuid::Uuid::new_v4(),
version_id: 0,
content: base64_to_bytes(&request.content_base64)
.context("Cannot convert base64 encoded content to bytes")
.map_err(client_error)?,
created_date: request.created_date,
relative_path: request.relative_path,
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()))
}

13
backend/sync_server/src/server/delete_document.rs
View file

@ -13,7 +13,7 @@ use serde::Deserialize;
use super::{auth::auth, requests::DeleteDocumentVersion};
use crate::{
app_state::AppState,
database::models::{DocumentId, StoredDocumentVersion, VaultId},
database::models::{StoredDocumentVersion, VaultId},
errors::{not_found_error, server_error, SyncServerError},
};
@ -21,7 +21,7 @@ use crate::{
#[derive(Deserialize, JsonSchema)]
pub struct PathParams {
vault_id: VaultId,
document_id: DocumentId,
relative_path: String,
}
#[axum::debug_handler]
@ -29,7 +29,7 @@ pub async fn delete_document(
TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
Path(PathParams {
vault_id,
document_id,
relative_path,
}): Path<PathParams>,
State(state): State<AppState>,
Json(request): Json<DeleteDocumentVersion>,
@ -44,25 +44,24 @@ pub async fn delete_document(
let latest_version = state
.database
.get_latest_document_version(&vault_id, &document_id, Some(&mut transaction))
.get_latest_document(&vault_id, &relative_path, Some(&mut transaction))
.await
.map_err(server_error)?
.map(Ok)
.unwrap_or_else(|| {
Err(not_found_error(anyhow!(
"Latest document version of document `{}` not found",
document_id
relative_path
)))
})?;
let new_version = StoredDocumentVersion {
vault_id,
document_id,
relative_path,
version_id: latest_version.version_id + 1,
content: vec![],
created_date: request.created_date,
updated_date: chrono::Utc::now(),
relative_path: latest_version.relative_path,
is_deleted: true,
};

10
backend/sync_server/src/server/fetch_latest_document_version.rs
View file

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

11
backend/sync_server/src/server/requests.rs
View file

@ -4,20 +4,11 @@ use serde::{self, Deserialize};
use crate::database::models::DocumentVersionId;
#[derive(Debug, Deserialize, JsonSchema)]
#[serde(rename_all = "camelCase")]
pub struct CreateDocumentVersion {
pub created_date: DateTime<Utc>,
pub relative_path: String,
pub content_base64: String,
}
#[derive(Debug, Deserialize, JsonSchema)]
#[serde(rename_all = "camelCase")]
pub struct UpdateDocumentVersion {
pub parent_version_id: DocumentVersionId,
pub parent_version_id: Option<DocumentVersionId>,
pub created_date: DateTime<Utc>,
pub relative_path: String,
pub content_base64: String,
}

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

@ -14,7 +14,7 @@ use sync_lib::{base64_to_bytes, merge};
use super::{auth::auth, requests::UpdateDocumentVersion};
use crate::{
app_state::AppState,
database::models::{DocumentId, DocumentVersion, StoredDocumentVersion, VaultId},
database::models::{DocumentVersion, StoredDocumentVersion, VaultId},
errors::{client_error, not_found_error, server_error, SyncServerError},
};
@ -22,7 +22,7 @@ use crate::{
#[derive(Deserialize, JsonSchema)]
pub struct PathParams {
vault_id: VaultId,
document_id: DocumentId,
relative_path: String,
}
#[axum::debug_handler]
@ -30,25 +30,30 @@ pub async fn update_document(
TypedHeader(auth_header): TypedHeader<Authorization<Bearer>>,
Path(PathParams {
vault_id,
document_id,
relative_path,
}): Path<PathParams>,
State(state): State<AppState>,
Json(request): Json<UpdateDocumentVersion>,
) -> Result<Json<DocumentVersion>, SyncServerError> {
auth(&state, auth_header.token())?;
let parent = state
.database
.get_document_version(&vault_id, &document_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 parent_content = if let Some(parent_version_id) = request.parent_version_id {
state
.database
.get_document_version(&vault_id, &relative_path, &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 mut transaction = state
.database
@ -58,39 +63,32 @@ pub async fn update_document(
let latest_version = state
.database
.get_latest_document_version(&vault_id, &document_id, Some(&mut transaction))
.get_latest_document(&vault_id, &relative_path, Some(&mut transaction))
.await
.map_err(server_error)?
.map(Ok)
.unwrap_or_else(|| {
Err(not_found_error(anyhow!(
"Latest document version of document `{}` not found",
document_id
)))
})?;
if latest_version.is_deleted {
return Err(client_error(anyhow!(
"Document `{}` is deleted",
document_id
)));
}
.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)?;
let merged_content = merge(&parent.content, &latest_version.content, &content_bytes)
let next_version = latest_version
.as_ref()
.map(|v| v.version_id + 1)
.unwrap_or(0);
let latest_version_content = latest_version
.map(|v| v.content)
.unwrap_or_else(Vec::default);
let merged_content = merge(&parent_content, &latest_version_content, &content_bytes)
.context("Failed to decode bytes as UTF-8")
.map_err(client_error)?;
let new_version = StoredDocumentVersion {
vault_id,
document_id,
version_id: latest_version.version_id + 1,
relative_path,
version_id: next_version,
content: merged_content,
created_date: request.created_date,
relative_path: request.relative_path,
updated_date: chrono::Utc::now(),
is_deleted: false,
};