implement clear all documents

src/data/updates.rs

@@ -62,6 +62,16 @@ impl Data {
         Ok(update.into())
     }
 
+    pub async fn clear_documents(
+        &self,
+        index: impl AsRef<str>,
+    ) -> 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())
+    }
+
     #[inline]
     pub fn get_update_status(&self, index: impl AsRef<str>, uid: u64) -> anyhow::Result<Option<UpdateStatus>> {
         self.index_controller.update_status(index, uid)

src/index_controller/local_index_controller/mod.rs

@@ -182,6 +182,14 @@ impl IndexController for LocalIndexController {
             primary_key,
         })
     }
+
+    fn clear_documents(&self, index: impl AsRef<str>) -> anyhow::Result<super::UpdateStatus> {
+        let (_, update_store) = self.indexes.index(&index)?
+            .with_context(|| format!("Index {:?} doesn't exist", index.as_ref()))?;
+        let meta = UpdateMeta::ClearDocuments;
+        let pending = update_store.register_update(meta, &[]).unwrap();
+        Ok(pending.into())
+    }
 }
 
 fn update_primary_key(index: impl AsRef<Index>, primary_key: impl AsRef<str>) -> anyhow::Result<()> {

src/index_controller/local_index_controller/update_store.rs

@@ -254,6 +254,7 @@ where
     /// Trying to abort an update that is currently being processed, an update
     /// that as already been processed or which doesn't actually exist, will
     /// return `None`.
+    #[allow(dead_code)]
     pub fn abort_update(&self, update_id: u64) -> heed::Result<Option<Aborted<M>>> {
         let mut wtxn = self.env.write_txn()?;
         let key = BEU64::new(update_id);
@@ -281,6 +282,7 @@ where
 
     /// Aborts all the pending updates, and not the one being currently processed.
     /// Returns the update metas and ids that were successfully aborted.
+    #[allow(dead_code)]
     pub fn abort_pendings(&self) -> heed::Result<Vec<(u64, Aborted<M>)>> {
         let mut wtxn = self.env.write_txn()?;
         let mut aborted_updates = Vec::new();

src/index_controller/mod.rs

@@ -128,6 +128,9 @@ pub trait IndexController {
         data: &[u8],
     ) -> anyhow::Result<UpdateStatus>;
 
+    /// Clear all documents in the given index.
+    fn clear_documents(&self, index: impl AsRef<str>) -> anyhow::Result<UpdateStatus>;
+
     /// Updates an index settings. If the index does not exist, it will be created when the update
     /// is applied to the index.
     fn update_settings<S: AsRef<str>>(&self, index_uid: S, settings: Settings) -> anyhow::Result<UpdateStatus>;

src/routes/document.rs

@@ -169,8 +169,17 @@ async fn delete_documents(
 
 #[delete("/indexes/{index_uid}/documents", wrap = "Authentication::Private")]
 async fn clear_all_documents(
-    _data: web::Data<Data>,
+    data: web::Data<Data>,
-    _path: web::Path<IndexParam>,
+    path: web::Path<IndexParam>,
 ) -> Result<HttpResponse, ResponseError> {
-    todo!()
+    match data.clear_documents(&path.index_uid).await {
+        Ok(update) => {
+            let json = serde_json::to_string(&update).unwrap();
+            Ok(HttpResponse::Ok().body(json))
+        }
+        Err(e) => {
+            error!("{}", e);
+            unimplemented!();
+        }
+    }
 }