feat(model-server): validation of operations in a version

The model server now executes the operations defined a version and checks if they actually produce
the new model referenced in that version.
This is important for not losing changes during a merge, because a merge is done by simply
re-executing these operations in a different order.

Author: slisson

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/IdentityPreservingNodeAssociation.kt

@@ -17,7 +17,7 @@ class IdentityPreservingNodeAssociation(
     override fun resolveTarget(sourceNode: IReadableNode): IWritableNode? {
         val sourceReference = sourceNode.getNodeReference()
         val targetReference = overrides[sourceReference] ?: sourceReference
-        return targetModel.resolveNode(targetReference)
+        return targetModel.tryResolveNode(targetReference)
     }
 
     override fun associate(

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/NodeAssociationToModelServer.kt

@@ -61,7 +61,7 @@ class NodeAssociationFromModelServer(val branch: IBranch, val targetModel: IMuta
 
     override fun resolveTarget(sourceNode: IReadableNode): IWritableNode? {
         return (pendingAssociations[nodeId(sourceNode)] ?: sourceNode.getOriginalReference())
-            ?.let { targetModel.resolveNode(NodeReference(it)) }
+            ?.let { targetModel.tryResolveNode(NodeReference(it)) }
     }
 
     override fun associate(sourceNode: IReadableNode, targetNode: IWritableNode) {

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/TransientNodeAssociation.kt

@@ -30,7 +30,7 @@ class TransientNodeAssociation(val writeOriginalIds: Boolean, val targetModel: I
     override fun resolveTarget(sourceNode: IReadableNode): IWritableNode? {
         val ref = sourceNode.getOriginalOrCurrentReference()
         return associations[ref]
-            ?: targetModel.resolveNode(NodeReference(ref))
+            ?: targetModel.tryResolveNode(NodeReference(ref))
     }
 
     override fun associate(

bulk-model-sync-lib/src/jvmMain/kotlin/org/modelix/model/sync/bulk/InvalidationTree.kt

@@ -34,7 +34,7 @@ class DefaultInvalidationTree(val root: INodeReference, sizeLimit: Int = 100_000
         model: IModel,
         nodeId: INodeReference,
     ): List<INodeReference> {
-        return model.resolveNode(nodeId)
+        return model.tryResolveNode(nodeId)
             ?.ancestors(includeSelf = true)
             ?.map { it.getNodeReference().toSerialized() }
             ?.toList()

model-api/src/commonMain/kotlin/org/modelix/model/api/IModel.kt

@@ -7,21 +7,25 @@ import org.modelix.model.area.IAreaReference
 interface IModel : ITransactionManager {
     fun getRootNode(): IReadableNode
     fun getRootNodes(): List<IReadableNode>
-    fun resolveNode(ref: INodeReference): IReadableNode?
+    fun tryResolveNode(ref: INodeReference): IReadableNode?
+    fun resolveNode(ref: INodeReference): IReadableNode = tryResolveNode(ref) ?: throw NodeNotFoundException(ref, this)
 }
 
 interface IMutableModel : IModel {
     fun asArea(): IArea = ModelAsArea(this)
     override fun getRootNode(): IWritableNode
     override fun getRootNodes(): List<IWritableNode>
-    override fun resolveNode(ref: INodeReference): IWritableNode?
+    override fun tryResolveNode(ref: INodeReference): IWritableNode?
+    override fun resolveNode(ref: INodeReference): IWritableNode {
+        return super.resolveNode(ref) as IWritableNode
+    }
 }
 
 data class AreaAsModel(val area: IArea) : IMutableModel {
     override fun asArea(): IArea = area
     override fun getRootNode(): IWritableNode = area.getRoot().asWritableNode()
     override fun getRootNodes(): List<IWritableNode> = listOf(getRootNode())
-    override fun resolveNode(ref: INodeReference): IWritableNode? = area.resolveNode(ref)?.asWritableNode()
+    override fun tryResolveNode(ref: INodeReference): IWritableNode? = area.resolveNode(ref)?.asWritableNode()
     override fun <R> executeRead(body: () -> R): R = area.executeRead(body)
     override fun <R> executeWrite(body: () -> R): R = area.executeWrite(body)
     override fun canRead(): Boolean = area.canRead()
@@ -35,7 +39,7 @@ data class ModelAsArea(val model: IMutableModel) : IArea, IAreaReference {
 
     override fun resolveConcept(ref: IConceptReference): IConcept? = ILanguageRepository.resolveConcept(ref)
 
-    override fun resolveNode(ref: INodeReference): INode? = model.resolveNode(ref)?.asLegacyNode()
+    override fun resolveNode(ref: INodeReference): INode? = model.tryResolveNode(ref)?.asLegacyNode()
 
     override fun resolveOriginalNode(ref: INodeReference): INode? = resolveNode(ref)
 
@@ -63,3 +67,5 @@ data class ModelAsArea(val model: IMutableModel) : IArea, IAreaReference {
         throw UnsupportedOperationException()
     }
 }
+
+class NodeNotFoundException(nodeRef: INodeReference, model: IModel) : NoSuchElementException("Node not found: $nodeRef")

model-api/src/commonMain/kotlin/org/modelix/model/api/LocalPNodeReference.kt

@@ -14,7 +14,10 @@ data class LocalPNodeReference(val id: Long) : INodeReference() {
         return id.toULong().toString(16)
     }
 
-    override fun toString(): String {
-        return "LocalPNodeReference_${id.toString(16)}"
+    companion object {
+        fun tryConvert(ref: INodeReference): LocalPNodeReference? {
+            if (ref is LocalPNodeReference) return ref
+            return ref.serialize().toULongOrNull(16)?.let { LocalPNodeReference(it.toLong()) }
+        }
     }
 }

model-api/src/commonMain/kotlin/org/modelix/model/api/PNodeReference.kt

@@ -16,10 +16,6 @@ data class PNodeReference(val id: Long, val treeId: String) : INodeReference() {
         return "modelix:$branchId/${id.toString(16)}"
     }
 
-    override fun toString(): String {
-        return serialize()
-    }
-
     companion object {
         fun deserialize(serialized: String): PNodeReference {
             return requireNotNull(tryDeserialize(serialized)) {

model-datastructure/src/commonMain/kotlin/org/modelix/datastructures/model/DefaultModelTree.kt

@@ -59,11 +59,11 @@ class DefaultModelTree(nodesMap: IPersistentMap<INodeReference, NodeObjectData<I
 class NodeNotFoundException(nodeId: Any?) : RuntimeException("Node doesn't exist: $nodeId")
 
 @JvmName("asModelTreeWithNodeReferences")
-fun IPersistentMap<INodeReference, NodeObjectData<INodeReference>>.asModelTree(treeId: TreeId): IModelTree<INodeReference> {
+fun IPersistentMap<INodeReference, NodeObjectData<INodeReference>>.asModelTree(treeId: TreeId): IGenericModelTree<INodeReference> {
     return DefaultModelTree(this, treeId)
 }
 
 @JvmName("asModelTreeWithInt64")
-fun IPersistentMap<Long, NodeObjectData<Long>>.asModelTree(treeId: TreeId): IModelTree<Long> {
+fun IPersistentMap<Long, NodeObjectData<Long>>.asModelTree(treeId: TreeId): IGenericModelTree<Long> {
     return Int64ModelTree(this, treeId)
 }

model-datastructure/src/commonMain/kotlin/org/modelix/datastructures/model/GenericModelTree.kt

@@ -24,7 +24,7 @@ import org.modelix.streams.plus
 abstract class GenericModelTree<NodeId>(
     val nodesMap: IPersistentMap<NodeId, NodeObjectData<NodeId>>,
     private val treeId: TreeId,
-) : IModelTree<NodeId>, IStreamExecutorProvider by nodesMap {
+) : IGenericModelTree<NodeId>, IStreamExecutorProvider by nodesMap {
     protected abstract fun withNewMap(newNodesMap: IPersistentMap<NodeId, NodeObjectData<NodeId>>): GenericModelTree<NodeId>
     abstract override fun getRootNodeId(): NodeId
     protected fun toGlobalNodeReference(ref: INodeReference): INodeReference = when (ref) {
@@ -117,7 +117,7 @@ abstract class GenericModelTree<NodeId>(
         }
     }
 
-    override fun getChanges(oldVersion: IModelTree<NodeId>, changesOnly: Boolean): IStream.Many<ModelChangeEvent<NodeId>> {
+    override fun getChanges(oldVersion: IGenericModelTree<NodeId>, changesOnly: Boolean): IStream.Many<ModelChangeEvent<NodeId>> {
         require(oldVersion is GenericModelTree<NodeId>)
         if (nodesMap.asObject().getHash() == oldVersion.nodesMap.asObject().getHash()) return IStream.empty()
         return getChanges(oldVersion, nodesMap, oldVersion.nodesMap, changesOnly)

model-datastructure/src/commonMain/kotlin/org/modelix/datastructures/model/IModelTree.kt renamed to model-datastructure/src/commonMain/kotlin/org/modelix/datastructures/model/IGenericModelTree.kt

@@ -13,6 +13,8 @@ import org.modelix.streams.IStream
 import org.modelix.streams.IStreamExecutorProvider
 import org.modelix.streams.plus
 
+typealias IModelTree = IGenericModelTree<INodeReference>
+
 /**
  * Persistent model implementation that supports bulk requests, bulk updates and non-Long node IDs.
  * Consistently using the streams API enables efficient lazy loading of model data.
@@ -22,14 +24,14 @@ import org.modelix.streams.plus
  * as the primary ID. This makes importing and updating models from source such as MPS easier and more efficient. No
  * need for maintaining a mapping between the MPS ID and the Modelix ID. Also, since there is no generated ID that has
  * a different value for each import, we don't have to check if a node already exists and reuse it. We can just run a
- * fresh import and then do a diff. All the data stored in the [IModelTree] also exists in the original source and if it
+ * fresh import and then do a diff. All the data stored in the [IGenericModelTree] also exists in the original source and if it
  * didn't change, we will end up with the same hash.
  * With a prefix tree like the [org.modelix.datastructures.patricia.PatriciaTrie] we can even re-run the import for
  * individual MPS models very efficiently, because all the nodes in the same model have the same model ID as a common
  * prefix of their node ID and will end up in the same subtree of the trie data structure, giving us a single hash for
  * the imported MPS model.
  */
-interface IModelTree<NodeId> : IStreamExecutorProvider {
+interface IGenericModelTree<NodeId> : IStreamExecutorProvider {
     fun asObject(): Object<CPTree>
     fun getNodeIdType(): IDataTypeConfiguration<NodeId>
 
@@ -57,17 +59,19 @@ interface IModelTree<NodeId> : IStreamExecutorProvider {
     fun getChildRoles(parentId: NodeId): IStream.Many<IChildLinkReference>
     fun getChildrenAndRoles(parentId: NodeId): IStream.Many<Pair<IChildLinkReference, IStream.Many<NodeId>>>
 
-    fun getChanges(oldVersion: IModelTree<NodeId>, changesOnly: Boolean): IStream.Many<ModelChangeEvent<NodeId>>
+    fun getChanges(oldVersion: IGenericModelTree<NodeId>, changesOnly: Boolean): IStream.Many<ModelChangeEvent<NodeId>>
 
-    fun mutate(operations: Iterable<MutationParameters<NodeId>>): IStream.One<IModelTree<NodeId>>
+    fun mutate(operations: Iterable<MutationParameters<NodeId>>): IStream.One<IGenericModelTree<NodeId>>
 
-    fun mutate(operation: MutationParameters<NodeId>): IStream.One<IModelTree<NodeId>> = mutate(listOf(operation))
+    fun mutate(operation: MutationParameters<NodeId>): IStream.One<IGenericModelTree<NodeId>> = mutate(listOf(operation))
 
     companion object {
         fun builder(): ModelTreeBuilder<Long> = ModelTreeBuilder.newWithInt64Ids()
     }
 }
 
+fun IGenericModelTree<*>.getHash() = asObject().getHash()
+
 sealed class MutationParameters<NodeId> {
     sealed class Node<NodeId> : MutationParameters<NodeId>() {
         abstract val nodeId: NodeId
@@ -112,36 +116,36 @@ sealed class MutationParameters<NodeId> {
     data class Remove<NodeId>(override val nodeId: NodeId) : Node<NodeId>()
 }
 
-fun <NodeId> IModelTree<NodeId>.getDescendants(nodeId: NodeId, includeSelf: Boolean): IStream.Many<NodeId> {
+fun <NodeId> IGenericModelTree<NodeId>.getDescendants(nodeId: NodeId, includeSelf: Boolean): IStream.Many<NodeId> {
     return if (includeSelf) {
         IStream.of(nodeId).plus(getDescendants(nodeId, false))
     } else {
         getChildren(nodeId).flatMap { getDescendants(it, true) }
     }
 }
 
-fun <NodeId> IModelTree<NodeId>.getAncestors(nodeId: NodeId, includeSelf: Boolean): IStream.Many<NodeId> {
+fun <NodeId> IGenericModelTree<NodeId>.getAncestors(nodeId: NodeId, includeSelf: Boolean): IStream.Many<NodeId> {
     return if (includeSelf) {
         IStream.of(nodeId).plus(getAncestors(nodeId, false))
     } else {
         getParent(nodeId).flatMap { getAncestors(it, true) }
     }
 }
 
-fun <NodeId> IModelTree<NodeId>.setProperty(nodeId: NodeId, role: IPropertyReference, value: String?): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.setProperty(nodeId: NodeId, role: IPropertyReference, value: String?): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.Property(nodeId, role, value))
 
-fun <NodeId> IModelTree<NodeId>.setReferenceTarget(sourceId: NodeId, role: IReferenceLinkReference, target: INodeReference): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.setReferenceTarget(sourceId: NodeId, role: IReferenceLinkReference, target: INodeReference): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.Reference(sourceId, role, target))
 
-fun <NodeId> IModelTree<NodeId>.moveNode(newParentId: NodeId, newRole: IChildLinkReference, newIndex: Int, childId: NodeId): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.moveNode(newParentId: NodeId, newRole: IChildLinkReference, newIndex: Int, childId: NodeId): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.Move(newParentId, newRole, newIndex, listOf(childId)))
 
-fun <NodeId> IModelTree<NodeId>.addNewChild(parentId: NodeId, role: IChildLinkReference, index: Int, childId: NodeId, concept: ConceptReference): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.addNewChild(parentId: NodeId, role: IChildLinkReference, index: Int, childId: NodeId, concept: ConceptReference): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.AddNew(parentId, role, index, listOf(childId to concept)))
 
-fun <NodeId> IModelTree<NodeId>.removeNode(nodeId: NodeId): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.removeNode(nodeId: NodeId): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.Remove(nodeId))
 
-fun <NodeId> IModelTree<NodeId>.changeConcept(nodeId: NodeId, concept: ConceptReference): IStream.One<IModelTree<NodeId>> =
+fun <NodeId> IGenericModelTree<NodeId>.changeConcept(nodeId: NodeId, concept: ConceptReference): IStream.One<IGenericModelTree<NodeId>> =
     mutate(MutationParameters.Concept(nodeId, concept))