Add create document endpoint

backend/sync_server/src/server.rs

@@ -1,7 +1,7 @@
 use crate::app_state::AppState;
 use aide::{
     axum::{
-        routing::{delete, get, put},
+        routing::{delete, get, post, put},
         ApiRouter,
     },
     openapi::{Info, OpenApi},
@@ -13,6 +13,7 @@ use axum::response::{IntoResponse, Response};
 use axum::{extract::DefaultBodyLimit, Extension};
 use axum::{extract::WebSocketUpgrade, Json};
 use log::info;
+mod create_document;
 mod delete_document;
 mod fetch_latest_document_version;
 mod fetch_latest_documents;
@@ -35,21 +36,25 @@ pub async fn create_server(app_state: AppState) -> Result<()> {
 
     let app = ApiRouter::new()
         .api_route(
-            "/vaults/:vault_id/documents/latest",
+            "/vaults/:vault_id/documents",
             get(fetch_latest_documents::fetch_latest_documents),
         )
         .api_route(
-            "/vaults/:vault_id/documents/:document_id/versions/:parent_version_id",
+            "/vaults/:vault_id/documents",
+            post(create_document::create_document),
+        )
+        .api_route(
+            "/vaults/:vault_id/documents/:document_id",
+            get(fetch_latest_document_version::fetch_latest_document_version),
+        )
+        .api_route(
+            "/vaults/:vault_id/documents/:document_id",
             put(update_document::update_document),
         )
         .api_route(
             "/vaults/:vault_id/documents/:document_id",
             delete(delete_document::delete_document),
         )
-        .api_route(
-            "/vaults/:vault_id/documents/:document_id/versions/latest",
-            get(fetch_latest_document_version::fetch_latest_document_version),
-        )
         .api_route("/ws", get(handler))
         .route("/", Scalar::new("/api.json").axum_route())
         .route("/api.json", axum::routing::get(serve_api))

backend/sync_server/src/server/create_document.rs

@@ -0,0 +1,43 @@
+use crate::app_state::AppState;
+use crate::database::models::DocumentVersionWithoutContent;
+use crate::database::models::StoredDocumentVersion;
+use crate::database::models::VaultId;
+use crate::errors::client_error;
+use crate::errors::server_error;
+use crate::errors::SyncServerError;
+use anyhow::Context;
+use axum::extract::Path;
+use axum::extract::State;
+use axum::Json;
+use sync_lib::base64_to_bytes;
+
+use super::requests::CreateDocumentVersion;
+
+#[axum::debug_handler]
+pub async fn create_document(
+    Path(vault_id): Path<VaultId>,
+    State(state): State<AppState>,
+    Json(request): Json<CreateDocumentVersion>,
+) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
+    let new_version = 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_binary: request.is_binary,
+        is_deleted: false,
+    };
+
+    state
+        .database
+        .insert_document_version(&new_version, None)
+        .await
+        .map_err(server_error)?;
+
+    Ok(Json(new_version.into()))
+}

backend/sync_server/src/server/requests.rs

@@ -2,6 +2,8 @@ use chrono::{DateTime, Utc};
 use schemars::JsonSchema;
 use serde::Deserialize;
 
+use crate::database::models::DocumentVersionId;
+
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct CreateDocumentVersion {
     pub created_date: DateTime<Utc>,
@@ -10,6 +12,15 @@ pub struct CreateDocumentVersion {
     pub is_binary: bool,
 }
 
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct UpdateDocumentVersion {
+    pub parent_version_id: DocumentVersionId,
+    pub created_date: DateTime<Utc>,
+    pub relative_path: String,
+    pub content_base64: String,
+    pub is_binary: bool,
+}
+
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct DeleteDocumentVersion {
     pub created_date: DateTime<Utc>,

backend/sync_server/src/server/update_document.rs

@@ -1,6 +1,5 @@
 use crate::app_state::AppState;
 use crate::database::models::DocumentId;
-use crate::database::models::DocumentVersionId;
 use crate::database::models::DocumentVersionWithoutContent;
 use crate::database::models::StoredDocumentVersion;
 use crate::database::models::VaultId;
@@ -16,28 +15,24 @@ use axum::Json;
 use sync_lib::base64_to_bytes;
 use sync_lib::base64_to_string;
 
-use super::requests::CreateDocumentVersion;
+use super::requests::UpdateDocumentVersion;
 
 #[axum::debug_handler]
 pub async fn update_document(
-    Path((vault_id, document_id, parent_version_id)): Path<(
-        VaultId,
-        DocumentId,
-        DocumentVersionId,
-    )>,
+    Path((vault_id, document_id)): Path<(VaultId, DocumentId)>,
     State(state): State<AppState>,
-    Json(request): Json<CreateDocumentVersion>,
+    Json(request): Json<UpdateDocumentVersion>,
 ) -> Result<Json<DocumentVersionWithoutContent>, SyncServerError> {
     let parent = state
         .database
-        .get_document_version(&vault_id, &document_id, &parent_version_id, None)
+        .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",
-                parent_version_id
+                &request.parent_version_id
             )))
         })?;