@fluidframework/tree 2.4.0-297027 → 2.4.0-299374

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, areEqualChangeAtomIdOpts, } from "../../core/index.js";
+import { EditBuilder, isEmptyFieldChanges, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, } 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";
@@ -82,7 +82,18 @@ export class ModularChangeFamily {
     composePair(change1, change2, revInfos, idState) {
         const { fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys } = this.composeAllFields(change1, change2, revInfos, idState);
         const { allBuilds, allDestroys, allRefreshers } = composeBuildsDestroysAndRefreshers(change1, change2);
-        return makeModularChangeset(fieldChanges, nodeChanges, nodeToParent, nodeAliases, crossFieldKeys, idState.maxId, revInfos, undefined, allBuilds, allDestroys, allRefreshers);
+        return makeModularChangeset({
+            fieldChanges,
+            nodeChanges,
+            nodeToParent,
+            nodeAliases,
+            crossFieldKeys,
+            maxId: idState.maxId,
+            revisions: revInfos,
+            builds: allBuilds,
+            destroys: allDestroys,
+            refreshers: allRefreshers,
+        });
     }
     composeAllFields(change1, change2, revInfos, idState) {
         if (hasConflicts(change1) && hasConflicts(change2)) {
@@ -303,15 +314,23 @@ export class ModularChangeFamily {
     /**
      * @param change - The change to invert.
      * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
+     * @param revisionForInvert - The revision for the invert changeset.
      * performing a sandwich rebase.
      */
-    invert(change, isRollback) {
+    invert(change, isRollback, revisionForInvert) {
         // Rollback changesets destroy the nodes created by the change being rolled back.
         const destroys = isRollback ? invertBuilds(change.change.builds) : undefined;
         // Destroys only occur in rollback changesets, which are never inverted.
         assert(change.change.destroys === undefined, 0x89a /* Unexpected destroys in change to invert */);
+        const revInfos = isRollback
+            ? [{ revision: revisionForInvert, rollbackOf: change.revision }]
+            : [{ revision: revisionForInvert }];
         if (hasConflicts(change.change)) {
-            return makeModularChangeset(undefined, undefined, undefined, undefined, undefined, change.change.maxId, [], undefined, undefined, destroys);
+            return makeModularChangeset({
+                maxId: change.change.maxId,
+                revisions: revInfos,
+                destroys,
+            });
         }
         const genId = idAllocatorFromMaxId(change.change.maxId ?? -1);
         const crossFieldTable = {
@@ -319,12 +338,12 @@ export class ModularChangeFamily {
             originalFieldToContext: new Map(),
             invertedNodeToParent: brand(change.change.nodeToParent.clone()),
         };
-        const { revInfos } = getRevInfoFromTaggedChanges([change]);
-        const revisionMetadata = revisionMetadataSourceFromInfo(revInfos);
-        const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata);
+        const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
+        const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
+        const invertedFields = this.invertFieldMap(change.change.fieldChanges, undefined, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
         const invertedNodes = newTupleBTree();
         change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
-            invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata));
+            invertedNodes.set([revision, localId], this.invertNodeChange(nodeChangeset, { revision, localId }, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert));
         });
         if (crossFieldTable.invalidatedFields.size > 0) {
             const fieldsToUpdate = crossFieldTable.invalidatedFields;
@@ -334,19 +353,29 @@ export class ModularChangeFamily {
                 const context = crossFieldTable.originalFieldToContext.get(fieldChange);
                 assert(context !== undefined, 0x851 /* Should have context for every invalidated field */);
                 const { invertedField, fieldId } = context;
-                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
+                const amendedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(originalFieldChange, isRollback, genId, revisionForInvert, new InvertManager(crossFieldTable, fieldChange, fieldId), revisionMetadata);
                 invertedField.change = brand(amendedChange);
             }
         }
         const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
-        return makeModularChangeset(invertedFields, invertedNodes, crossFieldTable.invertedNodeToParent, change.change.nodeAliases, crossFieldKeys, genId.getMaxId(), [], change.change.constraintViolationCount, undefined, destroys);
+        return makeModularChangeset({
+            fieldChanges: invertedFields,
+            nodeChanges: invertedNodes,
+            nodeToParent: crossFieldTable.invertedNodeToParent,
+            nodeAliases: change.change.nodeAliases,
+            crossFieldKeys,
+            maxId: genId.getMaxId(),
+            revisions: revInfos,
+            constraintViolationCount: change.change.constraintViolationCount,
+            destroys,
+        });
     }
-    invertFieldMap(changes, parentId, isRollback, genId, crossFieldTable, revisionMetadata) {
+    invertFieldMap(changes, parentId, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert) {
         const invertedFields = new Map();
         for (const [field, fieldChange] of changes) {
             const fieldId = { nodeId: parentId, field };
             const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
-            const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, manager, revisionMetadata);
+            const invertedChange = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).rebaser.invert(fieldChange.change, isRollback, genId, revisionForInvert, manager, revisionMetadata);
             const invertedFieldChange = {
                 ...fieldChange,
                 change: brand(invertedChange),
@@ -359,10 +388,10 @@ export class ModularChangeFamily {
         }
         return invertedFields;
     }
-    invertNodeChange(change, id, isRollback, genId, crossFieldTable, revisionMetadata) {
+    invertNodeChange(change, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert) {
         const inverse = {};
         if (change.fieldChanges !== undefined) {
-            inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, id, isRollback, genId, crossFieldTable, revisionMetadata);
+            inverse.fieldChanges = this.invertFieldMap(change.fieldChanges, id, isRollback, genId, crossFieldTable, revisionMetadata, revisionForInvert);
         }
         return inverse;
     }
@@ -398,7 +427,19 @@ 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);
-        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);
+        const rebased = makeModularChangeset({
+            fieldChanges: this.pruneFieldMap(rebasedFields, rebasedNodes),
+            nodeChanges: rebasedNodes,
+            nodeToParent: crossFieldTable.rebasedNodeToParent,
+            nodeAliases: change.nodeAliases,
+            crossFieldKeys: crossFieldTable.rebasedCrossFieldKeys,
+            maxId: idState.maxId,
+            revisions: change.revisions,
+            constraintViolationCount: constraintState.violationCount,
+            builds: change.builds,
+            destroys: change.destroys,
+            refreshers: change.refreshers,
+        });
         return rebased;
     }
     // This performs a first pass on all fields which have both new and base changes.
@@ -663,7 +704,7 @@ export class ModularChangeFamily {
         }
     }
     changeRevision(change, newRevision, rollbackOf) {
-        const oldRevisions = new Set(change.revisions === undefined
+        const oldRevisions = new Set(change.revisions === undefined || change.revisions.length === 0
             ? [undefined]
             : change.revisions.map((revInfo) => revInfo.revision));
         const updatedFields = this.replaceFieldMapRevisions(change.fieldChanges, oldRevisions, newRevision);
@@ -933,7 +974,19 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
         }
     }
     const { fieldChanges, nodeChanges, maxId, revisions, constraintViolationCount, builds, destroys, } = change;
-    return makeModularChangeset(fieldChanges, nodeChanges, change.nodeToParent, change.nodeAliases, change.crossFieldKeys, maxId, revisions, constraintViolationCount, builds, destroys, refreshers);
+    return makeModularChangeset({
+        fieldChanges,
+        nodeChanges,
+        nodeToParent: change.nodeToParent,
+        nodeAliases: change.nodeAliases,
+        crossFieldKeys: change.crossFieldKeys,
+        maxId: maxId,
+        revisions,
+        constraintViolationCount,
+        builds,
+        destroys,
+        refreshers,
+    });
 }
 /**
  * @param change - The change to convert into a delta.
@@ -1212,31 +1265,33 @@ class ComposeManager extends CrossFieldManagerI {
         return this.crossFieldTable;
     }
 }
-function makeModularChangeset(fieldChanges = undefined, nodeChanges = undefined, nodeToParent = undefined, nodeAliases = undefined, crossFieldKeys = undefined, maxId = -1, revisions = undefined, constraintViolationCount = undefined, builds, destroys, refreshers) {
+function makeModularChangeset(props = {
+    maxId: -1,
+}) {
     const changeset = {
-        fieldChanges: fieldChanges ?? new Map(),
-        nodeChanges: nodeChanges ?? newTupleBTree(),
-        nodeToParent: nodeToParent ?? newTupleBTree(),
-        nodeAliases: nodeAliases ?? newTupleBTree(),
-        crossFieldKeys: crossFieldKeys ?? newCrossFieldKeyTable(),
+        fieldChanges: props.fieldChanges ?? new Map(),
+        nodeChanges: props.nodeChanges ?? newTupleBTree(),
+        nodeToParent: props.nodeToParent ?? newTupleBTree(),
+        nodeAliases: props.nodeAliases ?? newTupleBTree(),
+        crossFieldKeys: props.crossFieldKeys ?? newCrossFieldKeyTable(),
     };
-    if (revisions !== undefined && revisions.length > 0) {
-        changeset.revisions = revisions;
+    if (props.revisions !== undefined && props.revisions.length > 0) {
+        changeset.revisions = props.revisions;
     }
-    if (maxId >= 0) {
-        changeset.maxId = brand(maxId);
+    if (props.maxId >= 0) {
+        changeset.maxId = brand(props.maxId);
     }
-    if (constraintViolationCount !== undefined && constraintViolationCount > 0) {
-        changeset.constraintViolationCount = constraintViolationCount;
+    if (props.constraintViolationCount !== undefined && props.constraintViolationCount > 0) {
+        changeset.constraintViolationCount = props.constraintViolationCount;
     }
-    if (builds !== undefined && builds.size > 0) {
-        changeset.builds = builds;
+    if (props.builds !== undefined && props.builds.size > 0) {
+        changeset.builds = props.builds;
     }
-    if (destroys !== undefined && destroys.size > 0) {
-        changeset.destroys = destroys;
+    if (props.destroys !== undefined && props.destroys.size > 0) {
+        changeset.destroys = props.destroys;
     }
-    if (refreshers !== undefined && refreshers.size > 0) {
-        changeset.refreshers = refreshers;
+    if (props.refreshers !== undefined && props.refreshers.size > 0) {
+        changeset.refreshers = props.refreshers;
     }
     return changeset;
 }
@@ -1263,11 +1318,12 @@ export class ModularEditBuilder extends EditBuilder {
     /**
      * @param firstId - The ID to associate with the first node
      * @param content - The node(s) to build. Can be in either Field or Node mode.
+     * @param revision - The revision to use for the build.
      * @returns A description of the edit that can be passed to `submitChanges`.
      */
-    buildTrees(firstId, content, idCompressor) {
+    buildTrees(firstId, content, revision, idCompressor) {
         if (content.mode === 1 /* CursorLocationType.Fields */ && content.getFieldLength() === 0) {
-            return { type: "global" };
+            return { type: "global", revision };
         }
         const builds = newTupleBTree();
         const chunkCompressor = {
@@ -1277,10 +1333,11 @@ export class ModularEditBuilder extends EditBuilder {
         const chunk = content.mode === 1 /* CursorLocationType.Fields */
             ? chunkFieldSingle(content, chunkCompressor)
             : chunkTree(content, chunkCompressor);
-        builds.set([undefined, firstId], chunk);
+        builds.set([revision, firstId], chunk);
         return {
             type: "global",
             builds,
+            revision,
         };
     }
     /**
@@ -1288,25 +1345,55 @@ export class ModularEditBuilder extends EditBuilder {
      * @param field - the field which is being edited
      * @param fieldKind - the kind of the field
      * @param change - the change to the field
-     * @param maxId - the highest `ChangesetLocalId` used in this change
+     * @param revision - the revision of the change
      */
-    submitChange(field, fieldKind, change) {
-        const crossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
-        const modularChange = buildModularChangesetFromField(field, { fieldKind, change }, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator, crossFieldKeys);
-        this.applyChange(modularChange);
+    submitChange(field, fieldKind, change, revision) {
+        const localCrossFieldKeys = getChangeHandler(this.fieldKinds, fieldKind).getCrossFieldKeys(change);
+        const modularChange = buildModularChangesetFromField({
+            path: field,
+            fieldChange: { fieldKind, change },
+            nodeChanges: newTupleBTree(),
+            nodeToParent: newTupleBTree(),
+            crossFieldKeys: newCrossFieldKeyTable(),
+            idAllocator: this.idAllocator,
+            localCrossFieldKeys,
+            revision,
+        });
+        this.applyChange(tagChange(modularChange, revision));
     }
-    submitChanges(changes) {
+    submitChanges(changes, revision) {
         const modularChange = this.buildChanges(changes);
-        this.applyChange(modularChange);
+        this.applyChange(tagChange(modularChange, revision));
     }
     buildChanges(changes) {
-        const changeMaps = changes.map((change) => makeAnonChange(change.type === "global"
-            ? makeModularChangeset(undefined, undefined, undefined, undefined, undefined, this.idAllocator.getMaxId(), undefined, undefined, change.builds)
-            : buildModularChangesetFromField(change.field, {
-                fieldKind: change.fieldKind,
-                change: change.change,
-            }, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator, getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change))));
-        const composedChange = this.changeFamily.rebaser.compose(changeMaps);
+        const revisions = new Set();
+        const changeMaps = changes.map((change) => {
+            revisions.add(change.revision);
+            return makeAnonChange(change.type === "global"
+                ? makeModularChangeset({
+                    maxId: this.idAllocator.getMaxId(),
+                    builds: change.builds,
+                    revisions: [{ revision: change.revision }],
+                })
+                : buildModularChangesetFromField({
+                    path: change.field,
+                    fieldChange: {
+                        fieldKind: change.fieldKind,
+                        change: change.change,
+                    },
+                    nodeChanges: newTupleBTree(),
+                    nodeToParent: newTupleBTree(),
+                    crossFieldKeys: newCrossFieldKeyTable(),
+                    idAllocator: this.idAllocator,
+                    localCrossFieldKeys: getChangeHandler(this.fieldKinds, change.fieldKind).getCrossFieldKeys(change.change),
+                    revision: change.revision,
+                }));
+        });
+        const revInfo = Array.from(revisions).map((revision) => ({ revision }));
+        const composedChange = {
+            ...this.changeFamily.rebaser.compose(changeMaps),
+            revisions: revInfo,
+        };
         const maxId = brand(this.idAllocator.getMaxId());
         if (maxId >= 0) {
             composedChange.maxId = maxId;
@@ -1316,14 +1403,23 @@ export class ModularEditBuilder extends EditBuilder {
     generateId(count) {
         return brand(this.idAllocator.allocate(count));
     }
-    addNodeExistsConstraint(path) {
+    addNodeExistsConstraint(path, revision) {
         const nodeChange = {
             nodeExistsConstraint: { violated: false },
         };
-        this.applyChange(buildModularChangesetFromNode(path, nodeChange, newTupleBTree(), newTupleBTree(), newCrossFieldKeyTable(), this.idAllocator));
+        this.applyChange(tagChange(buildModularChangesetFromNode({
+            path,
+            nodeChange,
+            nodeChanges: newTupleBTree(),
+            nodeToParent: newTupleBTree(),
+            crossFieldKeys: newCrossFieldKeyTable(),
+            idAllocator: this.idAllocator,
+            revision,
+        }), revision));
     }
 }
-function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId = undefined) {
+function buildModularChangesetFromField(props) {
+    const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
     const fieldChanges = new Map([[path.field, fieldChange]]);
     if (path.parent === undefined) {
         for (const key of localCrossFieldKeys) {
@@ -1335,12 +1431,19 @@ function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToPa
                 field: path.field,
             });
         }
-        return makeModularChangeset(fieldChanges, nodeChanges, nodeToParent, undefined, crossFieldKeys, idAllocator.getMaxId());
+        return makeModularChangeset({
+            fieldChanges,
+            nodeChanges,
+            nodeToParent,
+            crossFieldKeys,
+            maxId: idAllocator.getMaxId(),
+            revisions: [{ revision }],
+        });
     }
     const nodeChangeset = {
         fieldChanges,
     };
-    const parentId = { localId: brand(idAllocator.allocate()) };
+    const parentId = { localId: brand(idAllocator.allocate()), revision };
     for (const key of localCrossFieldKeys) {
         crossFieldKeys.set(key, { nodeId: parentId, field: path.field });
     }
@@ -1350,16 +1453,32 @@ function buildModularChangesetFromField(path, fieldChange, nodeChanges, nodeToPa
             field: path.field,
         });
     }
-    return buildModularChangesetFromNode(path.parent, nodeChangeset, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, parentId);
+    return buildModularChangesetFromNode({
+        path: path.parent,
+        nodeChange: nodeChangeset,
+        nodeChanges,
+        nodeToParent,
+        crossFieldKeys,
+        idAllocator,
+        revision,
+        nodeId: parentId,
+    });
 }
-function buildModularChangesetFromNode(path, nodeChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, nodeId = { localId: brand(idAllocator.allocate()) }) {
-    setInChangeAtomIdMap(nodeChanges, nodeId, nodeChange);
+function buildModularChangesetFromNode(props) {
+    const { path, nodeId = { localId: brand(props.idAllocator.allocate()), revision: props.revision }, } = props;
+    setInChangeAtomIdMap(props.nodeChanges, nodeId, props.nodeChange);
     const fieldChangeset = genericFieldKind.changeHandler.editor.buildChildChange(path.parentIndex, nodeId);
     const fieldChange = {
         fieldKind: genericFieldKind.identifier,
         change: fieldChangeset,
     };
-    return buildModularChangesetFromField({ parent: path.parent, field: path.parentField }, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator, [], nodeId);
+    return buildModularChangesetFromField({
+        ...props,
+        path: { parent: path.parent, field: path.parentField },
+        fieldChange,
+        localCrossFieldKeys: [],
+        childId: nodeId,
+    });
 }
 function getRevInfoFromTaggedChanges(changes) {
     let maxId = -1;