@fluidframework/tree 2.61.0 → 2.62.0

package/lib/shared-tree/treeCheckout.js

@@ -2,23 +2,23 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var _TreeCheckout_events, _TreeCheckout_transaction, _TreeCheckout_validatedCommits;
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { UsageError, } from "@fluidframework/telemetry-utils/internal";
-import { FluidClientVersion, noopValidator } from "../codec/index.js";
-import { AnchorSet, CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, } from "../core/index.js";
+import { FluidClientVersion, FormatValidatorNoOp } from "../codec/index.js";
+import { AnchorSet, CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, } from "../core/index.js";
 import { allowsRepoSuperset, buildForest, createNodeIdentifierManager, defaultSchemaPolicy, intoDelta, jsonableTreeFromCursor, makeFieldBatchCodec, } from "../feature-libraries/index.js";
 import { SquashingTransactionStack, SharedTreeBranch, TransactionResult, onForkTransitive, } from "../shared-tree-core/index.js";
 import { Breakable, disposeSymbol, getOrCreate } from "../util/index.js";
@@ -37,30 +37,32 @@ export function createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCod
     const schema = args?.schema ?? new TreeStoredSchemaRepository();
     const forest = args?.forest ?? buildForest(breaker, schema);
     const defaultCodecOptions = {
-        jsonValidator: noopValidator,
+        jsonValidator: FormatValidatorNoOp,
         oldestCompatibleClient: FluidClientVersion.v2_0,
     };
     const defaultFieldBatchVersion = 1;
     const changeFamily = args?.changeFamily ??
         new SharedTreeChangeFamily(revisionTagCodec, args?.fieldBatchCodec ??
             makeFieldBatchCodec(defaultCodecOptions, defaultFieldBatchVersion), defaultCodecOptions, args?.chunkCompressionStrategy, idCompressor);
+    // TODO: If a branch is passed in, is it supposed to be local main?
+    // Otherwise shouldn't we set `isSharedBranch` to false?
     const branch = args?.branch ??
         new SharedTreeBranch({
             change: changeFamily.rebaser.compose([]),
             revision: "root",
         }, changeFamily, () => idCompressor.generateCompressedId());
-    return new TreeCheckout(branch, false, changeFamily, schema, forest, mintRevisionTag, revisionTagCodec, idCompressor, args?.removedRoots, args?.logger, breaker, args?.disposeForksAfterTransaction);
+    return new TreeCheckout(branch, true, changeFamily, schema, forest, mintRevisionTag, revisionTagCodec, idCompressor, args?.removedRoots, args?.logger, breaker, args?.disposeForksAfterTransaction);
 }
 /**
  * An implementation of {@link ITreeCheckoutFork}.
  */
 export class TreeCheckout {
     constructor(branch, 
-    /** True if and only if this checkout is for a forked branch and not the "main branch" of the tree. */
-    isBranch, changeFamily, storedSchema, forest, mintRevisionTag, revisionTagCodec, idCompressor, removedRoots = makeDetachedFieldIndex("repair", revisionTagCodec, idCompressor), 
+    /** True if and only if this checkout is for a branch which is persisted and shared with other clients. */
+    isSharedBranch, changeFamily, storedSchema, forest, mintRevisionTag, revisionTagCodec, idCompressor, removedRoots = makeDetachedFieldIndex("repair", revisionTagCodec, idCompressor), 
     /** Optional logger for telemetry. */
     logger, breaker = new Breakable("TreeCheckout"), disposeForksAfterTransaction = true) {
-        this.isBranch = isBranch;
+        this.isSharedBranch = isSharedBranch;
         this.changeFamily = changeFamily;
         this.storedSchema = storedSchema;
         this.forest = forest;
@@ -85,6 +87,39 @@ export class TreeCheckout {
         this.revertibleCommitBranches = new Map();
         _TreeCheckout_events.set(this, createEmitter());
         this.events = __classPrivateFieldGet(this, _TreeCheckout_events, "f");
+        this.onAfterBranchChange = (event) => {
+            // The following logic allows revertibles to be generated for the change.
+            // Currently only appends (including merges and transaction commits) are supported.
+            if (event.type === "append") {
+                // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
+                //       Figure out a way to generate revertibles before the commits are garbage collected.
+                for (const commit of event.newCommits) {
+                    const kind = event.type === "append" ? event.kind : CommitKind.Default;
+                    const { change, revision } = commit;
+                    const getRevertible = hasSchemaChange(change)
+                        ? undefined
+                        : (onRevertibleDisposed) => {
+                            if (!withinEventContext) {
+                                throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
+                            }
+                            if (this.revertibleCommitBranches.get(revision) !== undefined) {
+                                throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
+                            }
+                            const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed);
+                            this.revertibleCommitBranches.set(revision, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork(commit));
+                            this.revertibles.add(revertible);
+                            return revertible;
+                        };
+                    let withinEventContext = true;
+                    __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: true, kind }, getRevertible);
+                    withinEventContext = false;
+                }
+            }
+            else if (this.isRemoteChangeEvent(event)) {
+                // TODO: figure out how to plumb through commit kind info for remote changes
+                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: false, kind: CommitKind.Default });
+            }
+        };
         this.onAfterChange = (event) => {
             this.editLock.lock();
             __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("beforeBatch", event);
@@ -92,36 +127,7 @@ export class TreeCheckout {
                 const revision = event.type === "rebase"
                     ? __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead().revision
                     : event.change.revision;
-                // Conflicts due to schema will be empty and thus are not applied.
-                for (const change of event.change.change.changes) {
-                    if (change.type === "data") {
-                        const delta = intoDelta(tagChange(change.innerChange, revision));
-                        this.withCombinedVisitor((visitor) => {
-                            visitDelta(delta, visitor, this.removedRoots, revision);
-                        });
-                    }
-                    else if (change.type === "schema") {
-                        // Schema changes from a current to a new schema are expected to be backwards compatible.
-                        // This guarantees that all data in the forest (which is valid before the schema change)
-                        // is also valid under the new schema.
-                        // Note however, that such schema changes may in some cases be rolled back:
-                        // Case 1: A transaction with a schema change may be aborted.
-                        // The transaction may have made some data changes that would render some trees invalid
-                        // under the old schema, but these changes will also be rolled back, thereby putting the forest
-                        // back in the state before the transaction, which is valid under the original (reinstated) schema.
-                        // Case 2: A branch with a schema change may be rebased such that the schema change (because
-                        // of a constraint) is no longer applied.
-                        // Such a branch may contain data changes that would render some trees invalid under the
-                        // original schema. These data changes may not necessarily be rolled back.
-                        // They will however be rebased over the rollback of the schema change. This rebasing will
-                        // ensure that these data changes are muted if they would render some trees invalid under the
-                        // original (reinstated) schema.
-                        this.storedSchema.apply(change.innerChange.schema.new);
-                    }
-                    else {
-                        fail(0xad1 /* Unknown Shared Tree change type. */);
-                    }
-                }
+                this.applyChange(event.change.change, revision);
             }
             __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
             this.editLock.unlock();
@@ -158,7 +164,22 @@ export class TreeCheckout {
         // #region Commit Validation
         /** Used to maintain the contract of {@link onCommitValid}(). */
         _TreeCheckout_validatedCommits.set(this, new WeakMap());
-        __classPrivateFieldSet(this, _TreeCheckout_transaction, new SquashingTransactionStack(branch, (commits) => {
+        __classPrivateFieldSet(this, _TreeCheckout_transaction, this.createTransactionStack(branch), "f");
+        this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
+        this.registerForBranchEvents();
+    }
+    registerForBranchEvents() {
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.on("afterChange", this.onAfterBranchChange);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("afterChange", this.onAfterChange);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
+    }
+    unregisterFromBranchEvents() {
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.off("afterChange", this.onAfterBranchChange);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("afterChange", this.onAfterChange);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("ancestryTrimmed", this.onAncestryTrimmed);
+    }
+    createTransactionStack(branch) {
+        return new SquashingTransactionStack(branch, (commits) => {
             const revision = this.mintRevisionTag();
             for (const transactionStep of commits) {
                 this.removedRoots.updateMajor(transactionStep.revision, revision);
@@ -188,43 +209,7 @@ export class TreeCheckout {
                 }
                 disposeForks?.();
             };
-        }), "f");
-        this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
-        branch.events.on("afterChange", (event) => {
-            // The following logic allows revertibles to be generated for the change.
-            // Currently only appends (including merges and transaction commits) are supported.
-            if (event.type === "append") {
-                // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
-                //       Figure out a way to generate revertibles before the commits are garbage collected.
-                for (const commit of event.newCommits) {
-                    const kind = event.type === "append" ? event.kind : CommitKind.Default;
-                    const { change, revision } = commit;
-                    const getRevertible = hasSchemaChange(change)
-                        ? undefined
-                        : (onRevertibleDisposed) => {
-                            if (!withinEventContext) {
-                                throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
-                            }
-                            if (this.revertibleCommitBranches.get(revision) !== undefined) {
-                                throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
-                            }
-                            const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed);
-                            this.revertibleCommitBranches.set(revision, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork(commit));
-                            this.revertibles.add(revertible);
-                            return revertible;
-                        };
-                    let withinEventContext = true;
-                    __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: true, kind }, getRevertible);
-                    withinEventContext = false;
-                }
-            }
-            else if (this.isRemoteChangeEvent(event)) {
-                // TODO: figure out how to plumb through commit kind info for remote changes
-                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: false, kind: CommitKind.Default });
-            }
         });
-        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("afterChange", this.onAfterChange);
-        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
     }
     exportVerbose() {
         const cursor = this.forest.allocateCursor("contentSnapshot");
@@ -246,6 +231,39 @@ export class TreeCheckout {
             cursor.free();
         }
     }
+    // Revision is the revision of the commit, if any, which caused this change.
+    applyChange(change, revision) {
+        // Conflicts due to schema will be empty and thus are not applied.
+        for (const innerChange of change.changes) {
+            if (innerChange.type === "data") {
+                const delta = intoDelta(tagChange(innerChange.innerChange, revision));
+                this.withCombinedVisitor((visitor) => {
+                    visitDelta(delta, visitor, this.removedRoots, revision);
+                });
+            }
+            else if (innerChange.type === "schema") {
+                // Schema changes from a current to a new schema are expected to be backwards compatible.
+                // This guarantees that all data in the forest (which is valid before the schema change)
+                // is also valid under the new schema.
+                // Note however, that such schema changes may in some cases be rolled back:
+                // Case 1: A transaction with a schema change may be aborted.
+                // The transaction may have made some data changes that would render some trees invalid
+                // under the old schema, but these changes will also be rolled back, thereby putting the forest
+                // back in the state before the transaction, which is valid under the original (reinstated) schema.
+                // Case 2: A branch with a schema change may be rebased such that the schema change (because
+                // of a constraint) is no longer applied.
+                // Such a branch may contain data changes that would render some trees invalid under the
+                // original schema. These data changes may not necessarily be rolled back.
+                // They will however be rebased over the rollback of the schema change. This rebasing will
+                // ensure that these data changes are muted if they would render some trees invalid under the
+                // original (reinstated) schema.
+                this.storedSchema.apply(innerChange.innerChange.schema.new);
+            }
+            else {
+                fail(0xad1 /* Unknown Shared Tree change type. */);
+            }
+        }
+    }
     withCombinedVisitor(fn) {
         const anchorVisitor = this.forest.anchors.acquireVisitor();
         const combinedVisitor = combineVisitors([this.forest.acquireVisitor(), anchorVisitor]);
@@ -346,16 +364,28 @@ export class TreeCheckout {
         const branch = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork();
         const storedSchema = this.storedSchema.clone();
         const forest = this.forest.clone(storedSchema, anchors);
-        const checkout = new TreeCheckout(branch, true, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this.removedRoots.clone(), this.logger, this.breaker, this.disposeForksAfterTransaction);
+        const checkout = new TreeCheckout(branch, false, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this.removedRoots.clone(), this.logger, this.breaker, this.disposeForksAfterTransaction);
         __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("fork", checkout);
         return checkout;
     }
+    switchBranch(branch) {
+        // TODO: Dispose old branch, if necessary
+        assert(!__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").isInProgress(), 0xc55 /* Cannot switch branches during a transaction */);
+        const diff = diffHistories(this.changeFamily.rebaser, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead(), branch.getHead(), this.mintRevisionTag);
+        this.unregisterFromBranchEvents();
+        __classPrivateFieldSet(this, _TreeCheckout_transaction, this.createTransactionStack(branch), "f");
+        this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
+        this.registerForBranchEvents();
+        // TODO: Rework eventing
+        this.applyChange(diff);
+        __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
+    }
     rebase(checkout) {
         this.checkNotDisposed("The target of the branch rebase has been disposed and cannot be rebased.");
         checkout.checkNotDisposed("The source of the branch rebase has been disposed and cannot be rebased.");
         this.editLock.checkUnlocked("Rebasing");
         assert(!checkout.transaction.isInProgress(), 0x9af /* A view cannot be rebased while it has a pending transaction */);
-        assert(checkout.isBranch, 0xa5d /* The main branch cannot be rebased onto another branch. */);
+        assert(!checkout.isSharedBranch, 0xa5d /* Shared branches cannot be rebased onto another branch. */);
         __classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").activeBranch.rebaseOnto(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch);
     }
     rebaseOnto(checkout) {
@@ -371,8 +401,8 @@ export class TreeCheckout {
             checkout.transaction.commit();
         }
         __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.merge(__classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").activeBranch);
-        if (disposeMerged && checkout.isBranch) {
-            // Dispose the merged checkout unless it is the main branch.
+        if (disposeMerged && !checkout.isSharedBranch) {
+            // Dispose the merged checkout unless it is a shared branch.
             checkout[disposeSymbol]();
         }
     }
@@ -485,10 +515,10 @@ export class TreeCheckout {
      */
     isRemoteChangeEvent(event) {
         return (
-        // Remote changes are only ever applied to the main branch
-        !this.isBranch &&
-            // Remote changes are applied to the main branch by rebasing it onto the trunk.
-            // No other rebases are allowed on the main branch, so we can use this to detect remote changes.
+        // Remote changes are only ever applied to shared branches
+        this.isSharedBranch &&
+            // Remote changes are applied to the branch by rebasing it onto the trunk.
+            // No other rebases are allowed on shared branches, so we can use this to detect remote changes.
             event.type === "rebase");
     }
     /**