implement delete single document

src/data/updates.rs

@@ -64,21 +64,19 @@ impl Data {
 
     pub async fn clear_documents(
         &self,
-        index: impl AsRef<str>,
+        index: impl AsRef<str> + Sync + Send + 'static,
     ) -> anyhow::Result<UpdateStatus> {
         let index_controller = self.index_controller.clone();
-        let index = index.as_ref().to_string();
         let update = tokio::task::spawn_blocking(move || index_controller.clear_documents(index)).await??;
         Ok(update.into())
     }
 
     pub async fn delete_documents(
         &self,
-        index: impl AsRef<str>,
+        index: impl AsRef<str> + Sync + Send + 'static,
         document_ids: Vec<String>,
     ) -> anyhow::Result<UpdateStatus> {
         let index_controller = self.index_controller.clone();
-        let index = index.as_ref().to_string();
         let update = tokio::task::spawn_blocking(move || index_controller.delete_documents(index, document_ids)).await??;
         Ok(update.into())
     }

src/index_controller/local_index_controller/update_handler.rs

@@ -187,7 +187,7 @@ impl UpdateHandler {
         let mut txn = self.index.write_txn()?;
         let mut builder = update_builder.delete_documents(&mut txn, &self.index)?;
 
-        // we ignore unexisting document ids
+        // We ignore unexisting document ids
         ids.iter().for_each(|id| { builder.delete_external_id(id); });
 
         match builder.execute() {
@@ -215,7 +215,7 @@ impl HandleUpdate<UpdateMeta, UpdateResult, String> for UpdateHandler {
         let result = match meta.meta() {
             DocumentsAddition { method, format } => self.update_documents(*format, *method, content, update_builder),
             ClearDocuments => self.clear_documents(update_builder),
-            DeleteDocuments => self.delete_documents(content, update_builder,),
+            DeleteDocuments => self.delete_documents(content, update_builder),
             Settings(settings) => self.update_settings(settings, update_builder),
             Facets(levels) => self.update_facets(levels, update_builder),
         };

src/index_controller/mod.rs

@@ -133,7 +133,7 @@ pub trait IndexController {
     /// Clear all documents in the given index.
     fn clear_documents(&self, index: impl AsRef<str>) -> anyhow::Result<UpdateStatus>;
 
-    /// Clear all documents in the given index.
+    /// Delete all documents in `document_ids`.
     fn delete_documents(&self, index: impl AsRef<str>, document_ids: Vec<String>) -> anyhow::Result<UpdateStatus>;
 
     /// Updates an index settings. If the index does not exist, it will be created when the update

src/routes/document.rs

@@ -30,8 +30,8 @@ type Document = IndexMap<String, Value>;
 
 #[derive(Deserialize)]
 struct DocumentParam {
-    _index_uid: String,
+    index_uid: String,
-    _document_id: String,
+    document_id: String,
 }
 
 pub fn services(cfg: &mut web::ServiceConfig) {
@@ -60,10 +60,19 @@ async fn get_document(
     wrap = "Authentication::Private"
 )]
 async fn delete_document(
-    _data: web::Data<Data>,
+    data: web::Data<Data>,
-    _path: web::Path<DocumentParam>,
+    path: web::Path<DocumentParam>,
 ) -> Result<HttpResponse, ResponseError> {
-    todo!()
+    match data.delete_documents(path.index_uid.clone(), vec![path.document_id.clone()]).await {
+        Ok(result) => {
+            let json = serde_json::to_string(&result).unwrap();
+            Ok(HttpResponse::Ok().body(json))
+        }
+        Err(e) => {
+            error!("{}", e);
+            unimplemented!()
+        }
+    }
 }
 
 #[derive(Deserialize)]
@@ -166,10 +175,10 @@ async fn delete_documents(
 ) -> Result<HttpResponse, ResponseError> {
     let ids = body
         .iter()
-        .map(ToString::to_string)
+        .map(|v| v.as_str().map(String::from).unwrap_or_else(|| v.to_string()))
         .collect();
 
-    match data.delete_documents(&path.index_uid, ids).await {
+    match data.delete_documents(path.index_uid.clone(), ids).await {
         Ok(result) => {
             let json = serde_json::to_string(&result).unwrap();
             Ok(HttpResponse::Ok().body(json))
@@ -186,7 +195,7 @@ async fn clear_all_documents(
     data: web::Data<Data>,
     path: web::Path<IndexParam>,
 ) -> Result<HttpResponse, ResponseError> {
-    match data.clear_documents(&path.index_uid).await {
+    match data.clear_documents(path.index_uid.clone()).await {
         Ok(update) => {
             let json = serde_json::to_string(&update).unwrap();
             Ok(HttpResponse::Ok().body(json))