Merge pull request #522 from modelix/feat/resolve-node-on-BranchJS

feat(model-client): add function to resolve a node given the node reference on BranchJS

Author: Oleksandr Dzhychko

model-client/src/jsMain/kotlin/org/modelix/model/client2/BranchJSImpl.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2024.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modelix.model.client2
+
+import INodeJS
+import INodeReferenceJS
+import org.modelix.kotlin.utils.UnstableModelixFeature
+import org.modelix.model.api.IBranch
+import org.modelix.model.api.INodeReferenceSerializer
+import org.modelix.model.api.getRootNode
+import org.modelix.model.area.getArea
+
+fun interface DisposeFunction {
+    fun invoke()
+}
+
+@OptIn(UnstableModelixFeature::class)
+class BranchJSImpl(
+    private val dispose: DisposeFunction,
+    private val branch: IBranch,
+) : BranchJS {
+
+    private val jsRootNode = toNodeJs(branch.getRootNode())
+
+    override val rootNode: INodeJS
+        get() {
+            return jsRootNode
+        }
+
+    override fun resolveNode(reference: INodeReferenceJS): INodeJS? {
+        val referenceObject = INodeReferenceSerializer.deserialize(reference as String)
+        return branch.getArea().resolveNode(referenceObject)?.let(::toNodeJs)
+    }
+
+    override fun dispose() {
+        dispose.invoke()
+    }
+}

model-client/src/jsMain/kotlin/org/modelix/model/client2/ClientJS.kt

@@ -19,6 +19,7 @@
 package org.modelix.model.client2
 
 import INodeJS
+import INodeReferenceJS
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.promise
@@ -31,7 +32,6 @@ import org.modelix.model.api.ITree
 import org.modelix.model.api.ITreeChangeVisitor
 import org.modelix.model.api.JSNodeConverter
 import org.modelix.model.api.PNodeAdapter
-import org.modelix.model.api.getRootNode
 import org.modelix.model.data.ModelData
 import org.modelix.model.lazy.RepositoryId
 import org.modelix.model.withAutoTransactions
@@ -47,11 +47,23 @@ fun loadModelsFromJson(
     json: Array<String>,
     changeCallback: (ChangeJS) -> Unit,
 ): INodeJS {
+    val branch = loadModelsFromJsonAsBranch(json, changeCallback)
+    return branch.rootNode
+}
+
+@UnstableModelixFeature(
+    reason = "The overarching task https://issues.modelix.org/issue/MODELIX-500 is in development.",
+    intendedFinalization = "The client is intended to be finalized when the overarching task is finished.",
+)
+@JsExport
+fun loadModelsFromJsonAsBranch(
+    json: Array<String>,
+    changeCallback: (ChangeJS) -> Unit,
+): BranchJS {
     val branch = ModelFacade.toLocalBranch(ModelFacade.newLocalTree())
     json.forEach { ModelData.fromJson(it).load(branch) }
     branch.addListener(ChangeListener(branch, changeCallback))
-    val rootNode = branch.withAutoTransactions().getRootNode()
-    return toNodeJs(rootNode)
+    return BranchJSImpl({}, branch.withAutoTransactions())
 }
 
 @UnstableModelixFeature(
@@ -121,9 +133,8 @@ class ClientJSImpl(private val modelClient: ModelClientV2) : ClientJS {
             model.start()
             val branch = model.getBranch()
             branch.addListener(ChangeListener(branch, changeCallback))
-            val rootNode = branch.withAutoTransactions().getRootNode()
-            val jsRootNode = toNodeJs(rootNode)
-            return@promise BranchJSImpl(model, jsRootNode)
+            val branchWithAutoTransaction = branch.withAutoTransactions()
+            return@promise BranchJSImpl({ model.dispose() }, branchWithAutoTransaction)
         }
     }
 
@@ -140,18 +151,7 @@ class ClientJSImpl(private val modelClient: ModelClientV2) : ClientJS {
 interface BranchJS {
     val rootNode: INodeJS
     fun dispose()
-}
-
-class BranchJSImpl(private val model: ReplicatedModel, private val jsRootNode: INodeJS) : BranchJS {
-
-    override val rootNode: INodeJS
-        get() {
-            return jsRootNode
-        }
-
-    override fun dispose() {
-        model.dispose()
-    }
+    fun resolveNode(reference: INodeReferenceJS): INodeJS?
 }
 
 class ChangeListener(private val branch: IBranch, private val changeCallback: (ChangeJS) -> Unit) : IBranchListener {

model-client/src/jsTest/kotlin/org/modelix/model/client2/BranchJSTest.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2023.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modelix.model.client2
+
+import org.modelix.kotlin.utils.UnstableModelixFeature
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+@OptIn(UnstableModelixFeature::class)
+class BranchJSTest {
+
+    @Test
+    fun canResolveNode() {
+        // Arrange
+        val data = """
+        {
+            "root": {
+                "children": [
+                    {
+                        "id": "aNode"
+                    }
+                ]
+            }
+        }
+        """.trimIndent()
+        val branch = loadModelsFromJsonAsBranch(arrayOf(data)) {}
+        val aNode = branch.rootNode.getAllChildren()[0]
+        val aNodeReference = aNode.getReference()
+
+        // Act
+        val resolvedNode = branch.resolveNode(aNodeReference)
+
+        // Assert
+        assertEquals(aNode, resolvedNode)
+    }
+
+    @Test
+    fun canResolveNodeNonExistingNode() {
+        // Arrange
+        val data = """
+        {
+            "root": {
+                "children": [
+                    {
+                        "id": "aNode"
+                    }
+                ]
+            }
+        }
+        """.trimIndent()
+        val branch = loadModelsFromJsonAsBranch(arrayOf(data)) {}
+        val aNode = branch.rootNode.getAllChildren()[0]
+        val aNodeReference = aNode.getReference()
+        branch.rootNode.removeChild(aNode)
+
+        // Act
+        val resolvedNode = branch.resolveNode(aNodeReference)
+
+        // Assert
+        assertNull(resolvedNode)
+    }
+}