diff --git a/src/satellite/src/db/store.rs b/src/satellite/src/db/store.rs
index 4ffc8c3b3..8415bca7e 100644
--- a/src/satellite/src/db/store.rs
+++ b/src/satellite/src/db/store.rs
@@ -302,27 +302,26 @@ fn assert_write_permission(
 pub fn delete_docs(collection: &CollectionKey) -> Result<(), String> {
     let rule = get_state_rule(collection)?;
 
-    match rule.mem() {
+    let keys = match rule.mem() {
         Memory::Heap => STATE.with(|state| {
-            let binding = state.borrow();
-            let docs = get_docs_heap(collection, &binding.heap.db.db)?;
-            delete_docs_impl(&docs, collection, &rule)
+            get_docs_heap(collection, &state.borrow().heap.db.db)
+                .map(|docs| docs.into_iter().map(|(key, _)| key.clone()).collect())
         }),
         Memory::Stable => STATE.with(|state| {
-            let binding = state.borrow();
-            let stable = get_docs_stable(collection, &binding.stable.db)?;
-            let docs: Vec<(&Key, &Doc)> = stable.iter().map(|(key, doc)| (&key.key, doc)).collect();
-            delete_docs_impl(&docs, collection, &rule)
+            get_docs_stable(collection, &state.borrow().stable.db)
+                .map(|docs| docs.iter().map(|(key, _)| key.key.clone()).collect())
         }),
-    }
+    }?;
+
+    delete_docs_impl(&keys, collection, &rule)
 }
 
-fn delete_docs_impl<'a>(
-    docs: &[(&'a Key, &'a Doc)],
+fn delete_docs_impl(
+    keys: &Vec<Key>,
     collection: &CollectionKey,
     rule: &Rule,
 ) -> Result<(), String> {
-    for (key, _) in docs {
+    for key in keys {
         delete_state_doc(collection, key, rule)?;
     }
 
diff --git a/src/satellite/src/storage/store.rs b/src/satellite/src/storage/store.rs
index fdb1c186b..1b7c7f058 100644
--- a/src/satellite/src/storage/store.rs
+++ b/src/satellite/src/storage/store.rs
@@ -74,22 +74,23 @@ pub fn delete_asset(
 pub fn delete_assets(collection: &CollectionKey) -> Result<(), String> {
     let rule = get_state_rule(collection)?;
 
-    match rule.mem() {
+    let full_paths = match rule.mem() {
         Memory::Heap => STATE.with(|state| {
-            let binding = state.borrow();
-            let assets = get_assets_heap(collection, &binding.heap.storage.assets);
-            delete_assets_impl(&assets, collection, &rule)
+            get_assets_heap(collection, &state.borrow().heap.storage.assets)
+                .iter()
+                .map(|(_, asset)| asset.key.full_path.clone())
+                .collect()
         }),
         Memory::Stable => STATE.with(|state| {
-            let binding = state.borrow();
-            let stable = get_assets_stable(collection, &binding.stable.assets);
-            let assets: Vec<(&FullPath, &Asset)> = stable
+            let stable = get_assets_stable(collection, &state.borrow().stable.assets);
+            stable
                 .iter()
-                .map(|(_, asset)| (&asset.key.full_path, asset))
-                .collect();
-            delete_assets_impl(&assets, collection, &rule)
+                .map(|(_, asset)| asset.key.full_path.clone())
+                .collect()
         }),
-    }
+    };
+
+    delete_assets_impl(&full_paths, collection, &rule)
 }
 
 pub fn list_assets(
@@ -287,11 +288,11 @@ fn delete_asset_impl(
 }
 
 fn delete_assets_impl(
-    assets: &Vec<(&FullPath, &Asset)>,
+    full_paths: &Vec<FullPath>,
     collection: &CollectionKey,
     rule: &Rule,
 ) -> Result<(), String> {
-    for (full_path, _) in assets {
+    for full_path in full_paths {
         let deleted_asset = delete_state_asset(collection, full_path, rule);
 
         match deleted_asset {