feat: bidirectional references

grovedb/src/batch.rs

@@ -475,8 +475,8 @@ mod tests {
     #[test]
     fn test_batch_validation_ok() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
-        let element2 = Element::Item(b"ayy2".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
+        let element2 = Element::new_item(b"ayy2".to_vec());
         let ops = vec![
             GroveDbOp::insert(vec![], b"key1".to_vec(), Element::empty_tree()),
             GroveDbOp::insert(
@@ -530,7 +530,7 @@ mod tests {
     #[test]
     fn test_batch_validation_broken_chain() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
         let ops = vec![
             GroveDbOp::insert(vec![], b"key1".to_vec(), Element::empty_tree()),
             GroveDbOp::insert(
@@ -551,7 +551,7 @@ mod tests {
     #[test]
     fn test_batch_validation_broken_chain_aborts_whole_batch() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
         let ops = vec![
             GroveDbOp::insert(
                 vec![TEST_LEAF.to_vec()],
@@ -583,7 +583,7 @@ mod tests {
     #[test]
     fn test_batch_validation_deletion_brokes_chain() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
 
         db.insert([], b"key1", Element::empty_tree(), None)
             .expect("cannot insert a subtree");
@@ -609,7 +609,7 @@ mod tests {
     #[test]
     fn test_batch_validation_deletion_and_insertion_restore_chain() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
         let ops = vec![
             GroveDbOp::insert(vec![], b"key1".to_vec(), Element::empty_tree()),
             GroveDbOp::insert(
@@ -640,7 +640,7 @@ mod tests {
     #[test]
     fn test_batch_validation_insert_into_existing_tree() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
 
         db.insert([TEST_LEAF], b"invalid", element.clone(), None)
             .expect("cannot insert value");
@@ -672,8 +672,8 @@ mod tests {
     #[test]
     fn test_batch_validation_nested_subtree_overwrite() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
-        let element2 = Element::Item(b"ayy2".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
+        let element2 = Element::new_item(b"ayy2".to_vec());
         db.insert([TEST_LEAF], b"key_subtree", Element::empty_tree(), None)
             .expect("cannot insert a subtree");
         db.insert([TEST_LEAF, b"key_subtree"], b"key2", element, None)
@@ -721,7 +721,11 @@ mod tests {
     fn test_batch_validation_root_leaf_removal() {
         let db = make_grovedb();
         let ops = vec![
-            GroveDbOp::insert(vec![], TEST_LEAF.to_vec(), Element::Item(b"ayy".to_vec())),
+            GroveDbOp::insert(
+                vec![],
+                TEST_LEAF.to_vec(),
+                Element::new_item(b"ayy".to_vec()),
+            ),
             GroveDbOp::insert(
                 vec![TEST_LEAF.to_vec()],
                 b"key1".to_vec(),
@@ -734,7 +738,7 @@ mod tests {
     #[test]
     fn test_merk_data_is_deleted() {
         let db = make_grovedb();
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
 
         db.insert([TEST_LEAF], b"key1", Element::empty_tree(), None)
             .expect("cannot insert a subtree");
@@ -743,7 +747,7 @@ mod tests {
         let ops = vec![GroveDbOp::insert(
             vec![TEST_LEAF.to_vec()],
             b"key1".to_vec(),
-            Element::Item(b"ayy2".to_vec()),
+            Element::new_item(b"ayy2".to_vec()),
         )];
 
         assert_eq!(
@@ -770,8 +774,8 @@ mod tests {
             .ok()
             .flatten()
             .expect("cannot get root hash");
-        let element = Element::Item(b"ayy".to_vec());
-        let element2 = Element::Item(b"ayy2".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
+        let element2 = Element::new_item(b"ayy2".to_vec());
 
         let ops = vec![
             GroveDbOp::insert(
@@ -848,7 +852,7 @@ mod tests {
             acc_path.push(p);
         }
 
-        let element = Element::Item(b"ayy".to_vec());
+        let element = Element::new_item(b"ayy".to_vec());
         let batch = vec![GroveDbOp::insert(
             acc_path.clone(),
             b"key".to_vec(),

grovedb/src/lib.rs

@@ -5,10 +5,7 @@ mod subtree;
 mod tests;
 mod util;
 mod visualize;
-use std::{
-    collections::{BTreeMap, HashMap},
-    path::Path,
-};
+use std::{collections::BTreeMap, path::Path};
 
 pub use merk::proofs::{query::QueryItem, Query};
 use merk::{self, Merk};

grovedb/src/operations/delete.rs

@@ -121,6 +121,62 @@ impl GroveDb {
                     delete_element()?;
                 }
             } else {
+                fn to_slice(x: &Vec<u8>) -> &[u8] {
+                    x.as_slice()
+                }
+
+                if let Element::Reference(ref base_element_path, _) = element {
+                    let (base_element_key, base_element_subtree_path) = base_element_path
+                        .split_last()
+                        .expect("reference path cannot be empty");
+
+                    let base_element_subtree_path_as_slice =
+                        base_element_subtree_path.iter().map(to_slice);
+                    let mut base_element = self.get(
+                        base_element_subtree_path_as_slice.clone(),
+                        base_element_key,
+                        transaction,
+                    )?;
+
+                    match base_element {
+                        Element::Tree(_) => {}
+                        Element::Item(_, ref mut references)
+                        | Element::Reference(_, ref mut references) => {
+                            let mut path_owned: Vec<Vec<u8>> =
+                                path_iter.clone().map(|x| x.to_vec()).collect();
+                            path_owned.push(key.to_vec());
+                            let position = references.iter().position(|path| path == &path_owned);
+                            if let Some(index) = position {
+                                references.remove(index);
+                                merk_optional_tx!(
+                                    self.db,
+                                    base_element_subtree_path_as_slice,
+                                    transaction,
+                                    mut subtree,
+                                    {
+                                        base_element.insert(&mut subtree, base_element_key)?;
+                                    }
+                                );
+                            }
+                        }
+                    }
+                }
+
+                if let Element::Item(_, references) | Element::Reference(_, references) = element {
+                    // recursively delete all references of to be deleted element
+                    for reference in references {
+                        let (referenced_key, reference_subtree_path) = reference
+                            .split_last()
+                            .expect("reference path cannot be empty");
+                        self.delete_internal(
+                            reference_subtree_path.iter().map(to_slice),
+                            referenced_key,
+                            false,
+                            transaction,
+                        )?;
+                    }
+                }
+
                 delete_element()?;
             }
             self.propagate_changes(path_iter, transaction)?;

grovedb/src/operations/get.rs

@@ -20,7 +20,7 @@ impl GroveDb {
         <P as IntoIterator>::IntoIter: DoubleEndedIterator + ExactSizeIterator + Clone,
     {
         match self.get_raw(path, key, transaction)? {
-            Element::Reference(reference_path) => {
+            Element::Reference(reference_path, _) => {
                 self.follow_reference(reference_path, transaction)
             }
             other => Ok(other),
@@ -48,7 +48,7 @@ impl GroveDb {
             }
             visited.insert(path);
             match current_element {
-                Element::Reference(reference_path) => path = reference_path,
+                Element::Reference(reference_path, _) => path = reference_path,
                 other => return Ok(other),
             }
             hops_left -= 1;
@@ -89,9 +89,9 @@ impl GroveDb {
         let results = elements
             .into_iter()
             .map(|element| match element {
-                Element::Reference(reference_path) => {
+                Element::Reference(reference_path, _) => {
                     let maybe_item = self.follow_reference(reference_path, transaction)?;
-                    if let Element::Item(item) = maybe_item {
+                    if let Element::Item(item, _) = maybe_item {
                         Ok(item)
                     } else {
                         Err(Error::InvalidQuery("the reference must result in an item"))
@@ -127,15 +127,15 @@ impl GroveDb {
         let results = elements
             .into_iter()
             .map(|element| match element {
-                Element::Reference(reference_path) => {
+                Element::Reference(reference_path, _) => {
                     let maybe_item = self.follow_reference(reference_path, transaction)?;
-                    if let Element::Item(item) = maybe_item {
+                    if let Element::Item(item, _) = maybe_item {
                         Ok(item)
                     } else {
                         Err(Error::InvalidQuery("the reference must result in an item"))
                     }
                 }
-                Element::Item(item) => Ok(item),
+                Element::Item(item, _) => Ok(item),
                 Element::Tree(_) => Err(Error::InvalidQuery(
                     "path_queries can only refer to items and references",
                 )),

grovedb/src/operations/insert.rs

@@ -29,26 +29,64 @@ impl GroveDb {
                     self.propagate_changes(path_iter, transaction)?;
                 }
             }
-            Element::Reference(ref reference_path) => {
+            Element::Reference(ref reference_path, _) => {
                 if path_iter.len() == 0 {
                     return Err(Error::InvalidPath(
                         "only subtrees are allowed as root tree's leafs",
                     ));
                 }
 
                 self.check_subtree_exists_invalid_path(path_iter.clone(), Some(key), transaction)?;
-                let referenced_element =
-                    self.follow_reference(reference_path.to_owned(), transaction)?;
 
+                // reference path denotes the element we are directly referencing
+                let (referenced_key, referenced_subtree_path) = reference_path
+                    .split_last()
+                    .ok_or(Error::InvalidPath("invalid reference path"))?;
+
+                let mut referenced_element = self.get_raw(
+                    referenced_subtree_path.iter().map(|x| x.as_slice()),
+                    referenced_key,
+                    transaction,
+                )?;
+
+                match referenced_element {
+                    Element::Item(_, ref mut references)
+                    | Element::Reference(_, ref mut references) => {
+                        let mut path_owned: Vec<Vec<u8>> =
+                            path_iter.clone().map(|x| x.to_vec()).collect();
+                        path_owned.push(key.to_vec());
+                        references.push(path_owned);
+                    }
+                    _ => {
+                        return Err(Error::InvalidPath("cannot reference tree items"));
+                    }
+                }
+
+                // update the reference list of the referenced item
+                merk_optional_tx!(
+                    self.db,
+                    referenced_subtree_path.iter().map(|x| x.as_slice()),
+                    transaction,
+                    mut subtree,
+                    {
+                        referenced_element.insert(&mut subtree, referenced_key.as_slice())?;
+                    }
+                );
+                self.propagate_changes(
+                    referenced_subtree_path.iter().map(|x| x.as_slice()),
+                    transaction,
+                );
+
+                // insert the reference
+                let base_element = self.follow_reference(reference_path.to_owned(), transaction)?;
                 merk_optional_tx!(self.db, path_iter.clone(), transaction, mut subtree, {
-                    element.insert_reference(&mut subtree, key, referenced_element.serialize()?)?;
+                    element.insert_reference(&mut subtree, key, base_element.serialize()?)?;
                 });
                 self.propagate_changes(path_iter, transaction)?;
             }
             _ => {
                 // If path is empty that means there is an attempt to insert
-                // something into a root tree and this branch is for anything
-                // but trees
+                // something into a root tree and this branch is for items
                 if path_iter.len() == 0 {
                     return Err(Error::InvalidPath(
                         "only subtrees are allowed as root tree's leaves",

grovedb/src/operations/proof/generate.rs

@@ -277,7 +277,7 @@ impl GroveDb {
                 Op::Push(node) | Op::PushInverted(node) => match node {
                     Node::KV(_, value) => {
                         let elem = Element::deserialize(value);
-                        if let Ok(Element::Reference(reference_path)) = elem {
+                        if let Ok(Element::Reference(reference_path, _)) = elem {
                             let referenced_elem = self.follow_reference(reference_path, None)?;
                             *value = referenced_elem.serialize().unwrap();
                         }

grovedb/src/operations/proof/verify.rs

@@ -120,7 +120,6 @@ impl ProofVerifier {
                                 continue;
                             }
 
-
                             if subquery_key.is_some() {
                                 if subquery_value.is_none() {
                                     self.verify_subquery_key(