exposed logical IDs in ywasm API

y-crdt · Horusiath · Mar 9, 2024 · Feb 11, 2024 · Feb 15, 2024 · Feb 16, 2024
commit 19cdcd87bac6efcf2a49c1bc12b70f8ad8322ad4
diff --git a/tests-wasm/y-doc.tests.js b/tests-wasm/y-doc.tests.js
@@ -86,7 +86,6 @@ export const testOnAfterTransaction = tc => {
 
     text.insert(0, 'hello world')
 
-    console.log(event)
     t.compare(event.beforeState, new Map());
     let state = new Map()
     state.set(1, 11)
@@ -298,4 +297,40 @@ export const testRoots = tc => {
     let d2 = new Y.YDoc()
     exchangeUpdates([d1, d2])
     t.compare(d2.roots(), [['a', undefined]])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testIds = tc => {
+    const d1 = new Y.YDoc()
+    const a1 = d1.getArray('a')
+
+    const d2 = new Y.YDoc()
+    d2.getArray('a') // root types need to be pre-initialized
+
+    const m1 = new Y.YMap({'key1': 'value1'})
+    a1.push([m1]) // set nested type on a first doc
+
+    const arrayId = a1.id
+    const mapId = m1.id
+
+    // sync
+    exchangeUpdates([d1, d2])
+
+    // resolve instances using identifiers
+    const m2 = d2.transact(tx => tx.get(mapId))
+
+    t.compare(m2.toJson(), {'key1': 'value1'})
+
+    const a2 = d2.transact(tx => tx.get(arrayId))
+
+    // modify instance on remote end and sync
+    m2.set('key1', 'value2')
+    a2.insert(0, ['abc'])
+
+    exchangeUpdates([d1, d2])
+
+    // check if first doc has correctly updated values
+    t.compare(a1.toJson(), ['abc', {'key1': 'value2'}])
 }
diff --git a/yrs/src/branch.rs b/yrs/src/branch.rs
@@ -7,7 +7,7 @@ use crate::types::{
     Entries, Event, Events, Path, PathSegment, RootRef, SharedRef, TypePtr, TypeRef,
 };
 use crate::{
-    ArrayRef, MapRef, Observer, Origin, ReadTxn, Subscription, TextRef, TransactionMut, Value,
+    ArrayRef, Doc, MapRef, Observer, Origin, ReadTxn, Subscription, TextRef, TransactionMut, Value,
     WriteTxn, XmlElementRef, XmlFragmentRef, XmlTextRef, ID,
 };
 use serde::{Deserialize, Serialize};
@@ -256,6 +256,15 @@ impl Branch {
         }
     }
 
+    pub fn as_subdoc(&self) -> Option<Doc> {
+        let item = self.item?;
+        if let ItemContent::Doc(_, doc) = &item.content {
+            Some(doc.clone())
+        } else {
+            None
+        }
+    }
+
     /// Returns an identifier of an underlying complex data type (eg. is it an Array or a Map).
     pub fn type_ref(&self) -> &TypeRef {
         &self.type_ref

diff --git a/ywasm/src/array.rs b/ywasm/src/array.rs
@@ -52,6 +52,14 @@ impl YArray {
         TYPE_REFS_ARRAY
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YArray`.
     ///
     /// Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.

diff --git a/ywasm/src/collection.rs b/ywasm/src/collection.rs
@@ -1,5 +1,6 @@
 use crate::transaction::{ImplicitTransaction, YTransaction};
 use crate::Result;
+use gloo_utils::format::JsValueSerdeExt;
 use std::ops::Deref;
 use wasm_bindgen::JsValue;
 use yrs::{BranchID, Doc, Hook, ReadTxn, SharedRef, Transact, Transaction, TransactionMut};
@@ -20,6 +21,18 @@ impl<P, S: SharedRef + 'static> SharedCollection<P, S> {
         SharedCollection::Integrated(Integrated::new(shared_ref, doc))
     }
 
+    pub fn id(&self) -> crate::Result<JsValue> {
+        match self {
+            SharedCollection::Prelim(_) => {
+                Err(JsValue::from_str(crate::js::errors::INVALID_PRELIM_OP))
+            }
+            SharedCollection::Integrated(c) => {
+                let branch_id = c.hook.id();
+                JsValue::from_serde(branch_id).map_err(|e| JsValue::from_str(&e.to_string()))
+            }
+        }
+    }
+
     pub fn try_integrated(&self) -> Result<(&BranchID, &Doc)> {
         match self {
             SharedCollection::Integrated(i) => {

diff --git a/ywasm/src/map.rs b/ywasm/src/map.rs
@@ -54,6 +54,14 @@ impl YMap {
         TYPE_REFS_MAP
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YMap`.
     ///
     /// Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.

diff --git a/ywasm/src/text.rs b/ywasm/src/text.rs
@@ -44,6 +44,14 @@ impl YText {
         TYPE_REFS_TEXT
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YArray`.
     ///
     /// Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.

diff --git a/ywasm/src/transaction.rs b/ywasm/src/transaction.rs
@@ -1,14 +1,28 @@
+use crate::array::YArray;
+use crate::collection::SharedCollection;
+use crate::doc::YDoc;
 use crate::js::Js;
+use crate::map::YMap;
+use crate::text::YText;
+use crate::weak::YWeakLink;
+use crate::xml_elem::YXmlElement;
+use crate::xml_frag::YXmlFragment;
+use crate::xml_text::YXmlText;
 use crate::Result;
+use gloo_utils::format::JsValueSerdeExt;
 use js_sys::Uint8Array;
 use std::ops::Deref;
 use wasm_bindgen::__rt::{Ref, RefMut};
 use wasm_bindgen::convert::{IntoWasmAbi, RefFromWasmAbi, RefMutFromWasmAbi};
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
+use yrs::types::TypeRef;
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::Encode;
-use yrs::{ReadTxn, TransactionMut, Update};
+use yrs::{
+    ArrayRef, BranchID, MapRef, ReadTxn, TextRef, TransactionMut, Update, WeakRef, XmlElementRef,
+    XmlFragmentRef, XmlTextRef,
+};
 
 #[wasm_bindgen]
 extern "C" {
@@ -89,6 +103,13 @@ impl YTransaction {
         }
     }
 
+    pub fn as_ref(&self) -> &TransactionMut<'static> {
+        match &self.inner {
+            Cell::Owned(v) => v,
+            Cell::Borrowed(v) => v,
+        }
+    }
+
     pub fn as_mut(&mut self) -> Result<&mut TransactionMut<'static>> {
         match &mut self.inner {
             Cell::Owned(v) => Ok(v),
@@ -134,6 +155,47 @@ impl YTransaction {
         }
     }
 
+    /// Given a logical identifier of the collection (obtained via `YText.id`, `YArray.id` etc.),
+    /// attempts to return an instance of that collection in the scope of current document.
+    ///
+    /// Returns `undefined` if an instance was not defined locally, haven't been integrated or
+    /// has been deleted.
+    #[wasm_bindgen(js_name = get)]
+    pub fn get(&self, id: JsValue) -> crate::Result<JsValue> {
+        let branch_id: BranchID =
+            JsValue::into_serde(&id).map_err(|e| JsValue::from_str(&e.to_string()))?;
+        let txn = self.as_ref();
+        let doc = txn.doc().clone();
+        Ok(match branch_id.get_branch(txn) {
+            None => JsValue::UNDEFINED,
+            Some(b) if b.is_deleted() => JsValue::UNDEFINED,
+            Some(b) => match b.type_ref() {
+                TypeRef::Array => {
+                    YArray(SharedCollection::integrated(ArrayRef::from(b), doc)).into()
+                }
+                TypeRef::Map => YMap(SharedCollection::integrated(MapRef::from(b), doc)).into(),
+                TypeRef::Text => YText(SharedCollection::integrated(TextRef::from(b), doc)).into(),
+                TypeRef::XmlElement(_) => {
+                    YXmlElement(SharedCollection::integrated(XmlElementRef::from(b), doc)).into()
+                }
+                TypeRef::XmlFragment => {
+                    YXmlFragment(SharedCollection::integrated(XmlFragmentRef::from(b), doc)).into()
+                }
+                TypeRef::XmlText => {
+                    YXmlText(SharedCollection::integrated(XmlTextRef::from(b), doc)).into()
+                }
+                TypeRef::WeakLink(_) => {
+                    YWeakLink(SharedCollection::integrated(WeakRef::from(b), doc)).into()
+                }
+                TypeRef::SubDoc => match b.as_subdoc() {
+                    None => JsValue::UNDEFINED,
+                    Some(doc) => YDoc(doc).into(),
+                },
+                TypeRef::XmlHook | TypeRef::Undefined => JsValue::UNDEFINED,
+            },
+        })
+    }
+
     /// Triggers a post-update series of operations without `free`ing the transaction. This includes
     /// compaction and optimization of internal representation of updates, triggering events etc.
     /// ywasm transactions are auto-committed when they are `free`d.

diff --git a/ywasm/src/weak.rs b/ywasm/src/weak.rs
@@ -60,6 +60,14 @@ impl YWeakLink {
         TYPE_REFS_WEAK
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Checks if current YWeakLink reference is alive and has not been deleted by its parent collection.
     /// This method only works on already integrated shared types and will return false is current
     /// type is preliminary (has not been integrated into document).

diff --git a/ywasm/src/xml_elem.rs b/ywasm/src/xml_elem.rs
@@ -100,6 +100,14 @@ impl YXmlElement {
         TYPE_REFS_XML_ELEMENT
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YXmlElement`.
     ///
     /// Preliminary instances can be nested into other shared data types.

diff --git a/ywasm/src/xml_frag.rs b/ywasm/src/xml_frag.rs
@@ -34,6 +34,14 @@ impl YXmlFragment {
         TYPE_REFS_XML_FRAGMENT
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YXmlFragment`.
     ///
     /// Preliminary instances can be nested into other shared data types.

diff --git a/ywasm/src/xml_text.rs b/ywasm/src/xml_text.rs
@@ -54,6 +54,14 @@ impl YXmlText {
         TYPE_REFS_XML_TEXT
     }
 
+    /// Gets unique logical identifier of this type, shared across peers collaborating on the same
+    /// document.
+    #[wasm_bindgen(getter, js_name = id)]
+    #[inline]
+    pub fn id(&self) -> crate::Result<JsValue> {
+        self.0.id()
+    }
+
     /// Returns true if this is a preliminary instance of `YXmlText`.
     ///
     /// Preliminary instances can be nested into other shared data types.