@fluidframework/tree 2.3.1 → 2.4.0-297027

package/lib/feature-libraries/modular-schema/modularChangeFamily.js

@@ -4,7 +4,7 @@
  */
 import { assert } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, } from "../../core/index.js";
+import { EditBuilder, isEmptyFieldChanges, makeAnonChange, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, } from "../../core/index.js";
 import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, } from "../../util/index.js";
 import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
@@ -102,7 +102,6 @@ export class ModularChangeFamily {
         }
         const genId = idAllocatorFromState(idState);
         const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
-        const crossFieldTable = newComposeTable(change1, change2);
         // We merge nodeChanges, nodeToParent, and nodeAliases from the two changesets.
         // The merged tables will have correct entries for all nodes which are only referenced in one of the input changesets.
         // During composeFieldMaps and composeInvalidatedElements we will find all nodes referenced in both input changesets
@@ -114,7 +113,8 @@ export class ModularChangeFamily {
         const composedNodeChanges = brand(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
         const composedNodeToParent = brand(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
         const composedNodeAliases = brand(mergeBTrees(change1.nodeAliases, change2.nodeAliases));
-        const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
+        const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
         // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
         const composedCrossFieldKeys = mergeBTrees(change1.crossFieldKeys, change2.crossFieldKeys);
@@ -129,7 +129,7 @@ export class ModularChangeFamily {
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
         const context = crossFieldTable.fieldToContext.get(fieldChange);
         assert(context !== undefined, 0x8cc /* Should have context for every invalidated field */);
-        const { change1: fieldChange1, change2: fieldChange2, composedChange } = context;
+        const { fieldId, change1: fieldChange1, change2: fieldChange2, composedChange } = context;
         const rebaser = getChangeHandler(this.fieldKinds, composedChange.fieldKind).rebaser;
         const composeNodes = (child1, child2) => {
             if (child1 !== undefined &&
@@ -140,7 +140,7 @@ export class ModularChangeFamily {
             }
             return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
         };
-        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, false), revisionMetadata);
+        const amendedChange = rebaser.compose(fieldChange1, fieldChange2, composeNodes, genId, new ComposeManager(crossFieldTable, fieldChange, fieldId, false), revisionMetadata);
         composedChange.change = brand(amendedChange);
     }
     /**
@@ -202,7 +202,7 @@ export class ModularChangeFamily {
             const [change1, change2] = areBaseFields
                 ? [fieldChange, emptyChange]
                 : [emptyChange, fieldChange];
-            const composedField = this.composeFieldChanges(change1, change2, genId, table, metadata);
+            const composedField = this.composeFieldChanges(fieldId, change1, change2, genId, table, metadata);
             if (fieldId.nodeId === undefined) {
                 composedFields.set(fieldId.field, composedField);
                 continue;
@@ -220,15 +220,16 @@ export class ModularChangeFamily {
         }
         affectedFields.clear();
     }
-    composeFieldMaps(change1, change2, genId, crossFieldTable, revisionMetadata) {
+    composeFieldMaps(change1, change2, parentId, genId, crossFieldTable, revisionMetadata) {
         const composedFields = new Map();
         if (change1 === undefined || change2 === undefined) {
             return change1 ?? change2 ?? composedFields;
         }
         for (const [field, fieldChange1] of change1) {
+            const fieldId = { nodeId: parentId, field };
             const fieldChange2 = change2.get(field);
             const composedField = fieldChange2 !== undefined
-                ? this.composeFieldChanges(fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
+                ? this.composeFieldChanges(fieldId, fieldChange1, fieldChange2, genId, crossFieldTable, revisionMetadata)
                 : fieldChange1;
             composedFields.set(field, composedField);
         }
@@ -250,9 +251,9 @@ export class ModularChangeFamily {
      *
      * Any composed `FieldChange` which is invalidated by new cross-field information will be added to `crossFieldTable.invalidatedFields`.
      */
-    composeFieldChanges(change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
+    composeFieldChanges(fieldId, change1, change2, idAllocator, crossFieldTable, revisionMetadata) {
         const { fieldKind, changeHandler, change1: change1Normalized, change2: change2Normalized, } = this.normalizeFieldChanges(change1, change2, idAllocator, revisionMetadata);
-        const manager = new ComposeManager(crossFieldTable, change1);
+        const manager = new ComposeManager(crossFieldTable, change1, fieldId);
         const composedChange = changeHandler.rebaser.compose(change1Normalized, change2Normalized, (child1, child2) => {
             if (child1 !== undefined && child2 !== undefined) {
                 setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
@@ -265,6 +266,7 @@ export class ModularChangeFamily {
             change: brand(composedChange),
         };
         crossFieldTable.fieldToContext.set(change1, {
+            fieldId,
             change1: change1Normalized,
             change2: change2Normalized,
             composedChange: composedField,
@@ -275,7 +277,7 @@ export class ModularChangeFamily {
     composeNodesById(nodeChanges1, nodeChanges2, composedNodes, composedNodeToParent, nodeAliases, id1, id2, idAllocator, crossFieldTable, revisionMetadata) {
         const nodeChangeset1 = nodeChangeFromId(nodeChanges1, id1);
         const nodeChangeset2 = nodeChangeFromId(nodeChanges2, id2);
-        const composedNodeChangeset = this.composeNodeChanges(nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
+        const composedNodeChangeset = this.composeNodeChanges(id1, nodeChangeset1, nodeChangeset2, idAllocator, crossFieldTable, revisionMetadata);
         setInChangeAtomIdMap(composedNodes, id1, composedNodeChangeset);
         if (!areEqualChangeAtomIds(id1, id2)) {
             composedNodes.delete([id2.revision, id2.localId]);
@@ -286,9 +288,9 @@ export class ModularChangeFamily {
         }
         crossFieldTable.composedNodes.add(composedNodeChangeset);
     }
-    composeNodeChanges(change1, change2, genId, crossFieldTable, revisionMetadata) {
+    composeNodeChanges(nodeId, change1, change2, genId, crossFieldTable, revisionMetadata) {
         const nodeExistsConstraint = change1.nodeExistsConstraint ?? change2.nodeExistsConstraint;
-        const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, genId, crossFieldTable, revisionMetadata);
+        const composedFieldChanges = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, nodeId, genId, crossFieldTable, revisionMetadata);
         const composedNodeChange = {};
         if (composedFieldChanges.size > 0) {
             composedNodeChange.fieldChanges = composedFieldChanges;
@@ -396,7 +398,8 @@ export class ModularChangeFamily {
         const rebasedFields = this.rebaseIntersectingFields(crossFieldTable, rebasedNodes, genId, constraintState, rebaseMetadata);
         this.rebaseInvalidatedElements(rebasedFields, rebasedNodes, crossFieldTable, rebaseMetadata, genId);
         this.updateConstraintsForFields(rebasedFields, NodeAttachState.Attached, constraintState, rebasedNodes);
-        return makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        const rebased = makeModularChangeset(this.pruneFieldMap(rebasedFields, rebasedNodes), rebasedNodes, crossFieldTable.rebasedNodeToParent, change.nodeAliases, crossFieldTable.rebasedCrossFieldKeys, idState.maxId, change.revisions, constraintState.violationCount, change.builds, change.destroys, change.refreshers);
+        return rebased;
     }
     // This performs a first pass on all fields which have both new and base changes.
     // TODO: Can we also handle additional passes in this method?
@@ -745,6 +748,42 @@ export class ModularChangeFamily {
         const emptyChange = getChangeHandler(this.fieldKinds, fieldKind).createEmpty();
         return { fieldKind, change: brand(emptyChange) };
     }
+    validateChangeset(change) {
+        let numNodes = this.validateFieldChanges(change, change.fieldChanges, undefined);
+        for (const [[revision, localId], node] of change.nodeChanges.entries()) {
+            if (node.fieldChanges === undefined) {
+                continue;
+            }
+            const nodeId = { revision, localId };
+            const numChildren = this.validateFieldChanges(change, node.fieldChanges, nodeId);
+            numNodes += numChildren;
+        }
+        assert(numNodes === change.nodeChanges.size, "Node table contains unparented nodes");
+    }
+    /**
+     * Asserts that each child and cross field key in each field has a correct entry in
+     * `nodeToParent` or `crossFieldKeyTable`.
+     * @returns the number of children found.
+     */
+    validateFieldChanges(change, fieldChanges, nodeParent) {
+        let numChildren = 0;
+        for (const [field, fieldChange] of fieldChanges.entries()) {
+            const fieldId = { nodeId: nodeParent, field };
+            const handler = getChangeHandler(this.fieldKinds, fieldChange.fieldKind);
+            for (const [child, _index] of handler.getNestedChanges(fieldChange.change)) {
+                const parentFieldId = getParentFieldId(change, child);
+                assert(areEqualFieldIds(parentFieldId, fieldId), "Inconsistent node parentage");
+                numChildren += 1;
+            }
+            for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
+                const fields = getFieldsForCrossFieldKey(change, keyRange);
+                assert(fields.length === 1 &&
+                    fields[0] !== undefined &&
+                    areEqualFieldIds(fields[0], fieldId), "Inconsistent cross field keys");
+            }
+        }
+        return numChildren;
+    }
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
@@ -1006,7 +1045,7 @@ export function getFieldKind(fieldKinds, kind) {
 export function getChangeHandler(fieldKinds, kind) {
     return getFieldKind(fieldKinds, kind).changeHandler;
 }
-function newComposeTable(baseChange, newChange) {
+function newComposeTable(baseChange, newChange, composedNodeToParent) {
     return {
         ...newCrossFieldTable(),
         baseChange,
@@ -1015,6 +1054,7 @@ function newComposeTable(baseChange, newChange) {
         newFieldToBaseField: new Map(),
         newToBaseNodeId: newTupleBTree(),
         composedNodes: new Set(),
+        composedNodeToParent,
         pendingCompositions: {
             nodeIdsToCompose: [],
             affectedBaseFields: newTupleBTree(),
@@ -1130,8 +1170,9 @@ class RebaseManager extends CrossFieldManagerI {
 }
 // TODO: Deduplicate this with RebaseTable
 class ComposeManager extends CrossFieldManagerI {
-    constructor(table, currentField, allowInval = true) {
+    constructor(table, currentField, fieldId, allowInval = true) {
         super(table, currentField, allowInval);
+        this.fieldId = fieldId;
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
@@ -1162,10 +1203,10 @@ class ComposeManager extends CrossFieldManagerI {
         super.set(target, revision, id, count, newValue, invalidateDependents);
     }
     onMoveIn(id) {
-        throw new Error("Method not implemented.");
+        setInChangeAtomIdMap(this.table.composedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        throw new Error("Method not implemented.");
+        throw new Error("Moving cross-field keys during compose is currently unsupported");
     }
     get table() {
         return this.crossFieldTable;
@@ -1544,4 +1585,7 @@ function getFromChangeAtomIdMap(map, id) {
 function setInChangeAtomIdMap(map, id, value) {
     map.set([id.revision, id.localId], value);
 }
+function areEqualFieldIds(a, b) {
+    return areEqualChangeAtomIdOpts(a.nodeId, b.nodeId) && a.field === b.field;
+}
 //# sourceMappingURL=modularChangeFamily.js.map