feat: add PrivateDocumentStore element type, gated to GROVE_V4

Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "grovedb-bulk-append-tree",
     "grovedb-dense-fixed-sized-merkle-tree",
     "grovedb-query",
+    "grovedb-private-document-store",
 ]
 
 [workspace.dependencies]

grovedb-bulk-append-tree/Cargo.toml

@@ -18,6 +18,9 @@ storage = [
     "grovedb-dense-fixed-sized-merkle-tree/storage",
 ]
 mem_store = ["grovedb-merkle-mountain-range/mem_store"]
+# Exposes `test_utils::MemStorageContext` to other crates' test builds so the
+# in-memory StorageContext harness lives in exactly one place.
+test-utils = ["storage"]
 
 [dependencies]
 grovedb-merkle-mountain-range = { version = "5.0.1", path = "../grovedb-merkle-mountain-range", default-features = false }

grovedb-bulk-append-tree/src/lib.rs

@@ -13,8 +13,8 @@ mod error;
 pub mod proof;
 mod tree;
 
-#[cfg(all(test, feature = "storage"))]
-pub(crate) mod test_utils;
+#[cfg(all(feature = "storage", any(test, feature = "test-utils")))]
+pub mod test_utils;
 
 // Re-export main types
 pub use chunk::{deserialize_chunk_blob, serialize_chunk_blob};

grovedb-bulk-append-tree/src/test_utils.rs

@@ -1,6 +1,9 @@
 //! Test utilities: in-memory StorageContext for BulkAppendTree tests.
 
-use std::{cell::RefCell, collections::HashMap};
+use std::{
+    cell::{Cell, RefCell},
+    collections::HashMap,
+};
 
 use grovedb_costs::{
     storage_cost::key_value_cost::KeyValueStorageCost, ChildrenSizesWithIsSumTree, CostContext,
@@ -13,22 +16,51 @@ use grovedb_storage::{Batch, RawIterator, StorageContext};
 /// Immediate reads and writes backed by a `HashMap`. Only `get` and `put`
 /// (data storage) have real implementations; all other `StorageContext`
 /// methods panic if called.
+///
+/// `fail_get` / `fail_put` inject storage faults. Tree code is full of arms
+/// that can only be reached when the backing store errors mid-operation —
+/// exactly the paths that decide whether a fault surfaces or is silently
+/// swallowed — and without injection those arms are untestable.
 #[derive(Default)]
-pub(crate) struct MemStorageContext {
+pub struct MemStorageContext {
     pub data: RefCell<HashMap<Vec<u8>, Vec<u8>>>,
+    pub fail_get: Cell<bool>,
+    pub fail_put: Cell<bool>,
 }
 
 impl MemStorageContext {
     pub fn new() -> Self {
         Self::default()
     }
+
+    /// Make every subsequent `get` return a storage error.
+    pub fn fail_reads(&self) {
+        self.fail_get.set(true);
+    }
+
+    /// Make every subsequent `put` return a storage error.
+    pub fn fail_writes(&self) {
+        self.fail_put.set(true);
+    }
+
+    /// Resume normal operation.
+    pub fn heal(&self) {
+        self.fail_get.set(false);
+        self.fail_put.set(false);
+    }
 }
 
 impl<'db> StorageContext<'db> for MemStorageContext {
     type Batch = MemBatch;
     type RawIterator = MemRawIterator;
 
     fn get<K: AsRef<[u8]>>(&self, key: K) -> CostResult<Option<Vec<u8>>, grovedb_storage::Error> {
+        if self.fail_get.get() {
+            return Err(grovedb_storage::Error::StorageError(
+                "injected read failure".to_string(),
+            ))
+            .wrap_with_cost(OperationCost::default());
+        }
         Ok(self.data.borrow().get(key.as_ref()).cloned()).wrap_with_cost(OperationCost::default())
     }
 
@@ -39,6 +71,12 @@ impl<'db> StorageContext<'db> for MemStorageContext {
         _children_sizes: ChildrenSizesWithIsSumTree,
         _cost_info: Option<KeyValueStorageCost>,
     ) -> CostResult<(), grovedb_storage::Error> {
+        if self.fail_put.get() {
+            return Err(grovedb_storage::Error::StorageError(
+                "injected write failure".to_string(),
+            ))
+            .wrap_with_cost(OperationCost::default());
+        }
         self.data
             .borrow_mut()
             .insert(key.as_ref().to_vec(), value.to_vec());
@@ -141,7 +179,7 @@ impl<'db> StorageContext<'db> for MemStorageContext {
 // ── Batch and RawIterator stubs ───────────────────────────────────────
 
 /// No-op batch (never used — MemStorageContext does immediate writes).
-pub(crate) struct MemBatch;
+pub struct MemBatch;
 
 impl Batch for MemBatch {
     fn put<K: AsRef<[u8]>>(
@@ -186,7 +224,7 @@ impl Batch for MemBatch {
 }
 
 /// Stub iterator (never used by the bulk append tree).
-pub(crate) struct MemRawIterator;
+pub struct MemRawIterator;
 
 impl RawIterator for MemRawIterator {
     fn seek_to_first(&mut self) -> CostContext<()> {