@fluidframework/tree 2.103.0 → 2.111.0

package/lib/shared-tree/treeCheckout.js

@@ -2,64 +2,21 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-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);
-};
+import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "tslib";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { isStableId } from "@fluidframework/id-compressor/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { FluidClientVersion, FormatValidatorNoOp, } from "../codec/index.js";
-import { CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, deltaFieldMapHasVisibleChanges, } from "../core/index.js";
+import { CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, deltaFieldMapHasVisibleChanges, findCommonAncestor, } from "../core/index.js";
 import { allowsRepoSuperset, buildForest, createNodeIdentifierManager, defaultSchemaPolicy, fieldBatchCodecBuilder, TreeStatus, intoDelta, jsonableTreeFromCursor, } from "../feature-libraries/index.js";
-import { SquashingTransactionStack, SharedTreeBranch, TransactionResult as InternalTransactionResult, onForkTransitive, } from "../shared-tree-core/index.js";
+import { SquashingTransactionStack, SharedTreeBranch, TransactionResult as InternalTransactionResult, } from "../shared-tree-core/index.js";
 import { getInnerNode, getKernel, customFromCursorStored, } from "../simple-tree/index.js";
 import { Breakable, breakingMethod, disposeSymbol, getOrCreate, hasSome, throwIfBroken, } from "../util/index.js";
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import { SharedTreeChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
+import { extractTransactionChangeProcessor } from "./transactionPostProcessor.js";
 /**
  * Yields all defined (non-`undefined`) labels from a {@link LabelTree}, depth-first.
  */
@@ -126,7 +83,7 @@ export function createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCod
             change: changeFamily.rebaser.compose([]),
             revision: "root",
         }, changeFamily, () => idCompressor.generateCompressedId());
-    return new TreeCheckout(branch, true, 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);
 }
 /**
  * Get the {@link TreeCheckout} associated with a given {@link TreeBranch}.
@@ -147,7 +104,7 @@ function getCheckout(context) {
  * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
  * @param constraints - The constraints to add to the transaction.
  *
- * @see {@link RunTransactionParams.preconditions}.
+ * @see {@link RunTransactionParamsAlpha.preconditions}.
  */
 export function addConstraintsToTransaction(checkout, constraintsOnRevert, constraints = []) {
     for (const constraint of constraints) {
@@ -220,7 +177,7 @@ let TreeCheckout = (() => {
             /** 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) {
+            logger, breaker = new Breakable("TreeCheckout")) {
                 this.isSharedBranch = (__runInitializers(this, _instanceExtraInitializers), isSharedBranch);
                 this.changeFamily = changeFamily;
                 this.storedSchema = storedSchema;
@@ -231,13 +188,12 @@ let TreeCheckout = (() => {
                 this._removedRoots = _removedRoots;
                 this.logger = logger;
                 this.breaker = breaker;
-                this.disposeForksAfterTransaction = disposeForksAfterTransaction;
                 this.disposed = false;
                 this.views = new Set();
                 /**
-                 * Set of revertibles maintained for automatic disposal
+                 * Revertibles maintained for automatic disposal
                  */
-                this.revertibles = new Set();
+                this.revertibles = new Map();
                 /**
                  * Each branch's head commit corresponds to a revertible commit.
                  * Maintaining a whole branch ensures the commit graph is not pruned in a way that would prevent the commit from
@@ -270,7 +226,7 @@ let TreeCheckout = (() => {
                                     }
                                     const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed, commitLabelTree);
                                     this.revertibleCommitBranches.set(revision, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork(commit));
-                                    this.revertibles.add(revertible);
+                                    this.revertibles.set(revision, revertible);
                                     return revertible;
                                 };
                             let withinEventContext = true;
@@ -297,16 +253,26 @@ let TreeCheckout = (() => {
                                 label: this.labelTreeNode?.label,
                                 labels: buildLabelsSet(this.labelTreeNode),
                             };
-                            __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", metadata, getRevertible);
+                            this.emitChangedLocked(() => {
+                                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", metadata, getRevertible);
+                            });
                             withinEventContext = false;
                         }
                     }
+                    else if (event.type === "remove") {
+                        // Commits that are rolled back should no longer be revertible
+                        for (const commit of event.removedCommits) {
+                            this.revertibles.get(commit.revision)?.dispose();
+                        }
+                    }
                     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,
-                            labels: new Set(),
+                        this.emitChangedLocked(() => {
+                            __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", {
+                                isLocal: false,
+                                kind: CommitKind.Default,
+                                labels: new Set(),
+                            });
                         });
                     }
                 };
@@ -484,9 +450,6 @@ let TreeCheckout = (() => {
             }
             createTransactionStack(branch) {
                 return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
-                    const disposeForks = this.disposeForksAfterTransaction
-                        ? trackForksForDisposal(this)
-                        : undefined;
                     // When each transaction is started, make a restorable checkpoint of the current state of removed roots
                     const restoreRemovedRoots = this._removedRoots.createCheckpoint();
                     return (result, viewUpdate) => {
@@ -513,7 +476,6 @@ let TreeCheckout = (() => {
                                 unreachableCase(result);
                             }
                         }
-                        disposeForks?.();
                     };
                 });
             }
@@ -537,6 +499,31 @@ let TreeCheckout = (() => {
                     cursor.free();
                 }
             }
+            /**
+             * Hold the `editLock` for the duration of `emit`, so that re-entrant edits, transactions,
+             * branch operations, etc. attempted from inside a `changed` listener throw the canonical
+             * "forbidden during a change event" {@link UsageError} via {@link EditLock.checkUnlocked}.
+             *
+             * @remarks
+             * Shared by both the local and remote `changed` emission paths in {@link TreeCheckout.onAfterBranchChange}.
+             * The `try`/`finally` ensures the lock is released even if a listener throws.
+             */
+            emitChangedLocked(emit) {
+                this.editLock.lock();
+                try {
+                    emit();
+                }
+                finally {
+                    // TODO: any event that throws potentially leaves the code which triggered that event,
+                    // and thus this checkout (and likely more) in a broken state.
+                    // Unlocking this editLock prevents future use of this broken state from giving a confusing error in this case,
+                    // however, a better approach would probably be to put something (this checkout and/or the editLock)
+                    // into a broken state (using a properly scoped `Breakable`),
+                    // likely by moving emitChangedLocked into EditLock, and having EditLock get a Breakable,
+                    // and having the new emitChangedLocked use `Breakable.use`.
+                    this.editLock.unlock();
+                }
+            }
             /**
              * Applies the given serialized change (as was produced via a `"changed"` event of another checkout) to this checkout.
              */
@@ -580,11 +567,22 @@ let TreeCheckout = (() => {
             }
             mountTransaction(params, isAsync) {
                 this.checkNotDisposed();
+                // Starting a transaction is an edit, so it is forbidden from within a change-event
+                // callback (where the edit lock is held), the same as direct edits. For the async
+                // entry point this throw is captured as a rejected promise by the `async` wrapper.
+                //
+                // Note: because runTransaction/runTransactionAsync are `@breakingMethod`, this throw also
+                // puts the checkout into a broken state (unlike a direct edit, which throws recoverably).
+                // That is the same pre-existing broken-state limitation tracked by the TODO in
+                // `emitChangedLocked`, not something specific to transactions.
+                this.editLock.checkUnlocked("Running a transaction");
                 if (isAsync && this.transaction.size > 0) {
                     throw new UsageError("An asynchronous transaction cannot be started while another transaction is already in progress.");
                 }
                 this.pushLabelFrame(params?.label);
-                this.transaction.start();
+                this.transaction.start({
+                    postProcessor: extractTransactionChangeProcessor(params?.postProcessor),
+                });
                 addConstraintsToTransaction(this, false, params?.preconditions);
             }
             unmountTransaction(transactionCallbackStatus, params) {
@@ -709,7 +707,7 @@ let TreeCheckout = (() => {
                         if (revertible.status === RevertibleStatus.Disposed) {
                             throw new UsageError("Unable to dispose a revertible that has already been disposed.");
                         }
-                        checkout.disposeRevertible(revertible, revision);
+                        checkout.disposeRevertible(revision);
                         onRevertibleDisposed?.(revertible);
                     },
                 };
@@ -742,12 +740,11 @@ let TreeCheckout = (() => {
                 if (this.transaction.size > 0) {
                     throw new UsageError("A view cannot be forked while it has a pending transaction.");
                 }
-                this.editLock.checkUnlocked("Branching");
                 const branch = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork();
                 const storedSchema = this.storedSchema.clone();
                 const forkBreaker = new Breakable("TreeCheckout");
                 const forest = this.forest.clone(storedSchema, forkBreaker);
-                const checkout = new _a(branch, false, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this._removedRoots.clone(), this.logger, forkBreaker, this.disposeForksAfterTransaction);
+                const checkout = new _a(branch, false, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this._removedRoots.clone(), this.logger, forkBreaker);
                 __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("fork", checkout);
                 return checkout;
             }
@@ -780,6 +777,18 @@ let TreeCheckout = (() => {
             rebaseOnto(branch) {
                 getCheckout(branch).rebase(this);
             }
+            isMissingEditsFrom(branch) {
+                const branchCheckout = getCheckout(branch);
+                const targetPath = [];
+                const ancestor = findCommonAncestor(this.mainBranch.getHead(), [
+                    branchCheckout.mainBranch.getHead(),
+                    targetPath,
+                ]);
+                if (ancestor === undefined) {
+                    throw new UsageError("Branches do not share a common ancestor.");
+                }
+                return targetPath.length > 0;
+            }
             merge(branch, disposeMerged = true) {
                 const checkout = getCheckout(branch);
                 this.checkNotDisposed("The target branch of the merge has been disposed and cannot be merged.");
@@ -848,14 +857,14 @@ let TreeCheckout = (() => {
                 __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
             }
             purgeRevertibles() {
-                for (const revertible of this.revertibles) {
+                for (const revertible of this.revertibles.values()) {
                     revertible.dispose();
                 }
             }
-            disposeRevertible(revertible, revision) {
+            disposeRevertible(revision) {
                 this.revertibleCommitBranches.get(revision)?.dispose();
                 this.revertibleCommitBranches.delete(revision);
-                this.revertibles.delete(revertible);
+                this.revertibles.delete(revision);
             }
             revertRevertible(revision, kind, labelTree) {
                 this.editLock.checkUnlocked("Reverting a commit");
@@ -1095,10 +1104,7 @@ class EditLock {
      */
     checkUnlocked(action) {
         if (this.locked) {
-            // These type assertions ensure that the event name strings used here match the actual event names
-            const nodeChanged = "nodeChanged";
-            const treeChanged = "treeChanged";
-            throw new UsageError(`${action} is forbidden during a ${nodeChanged} or ${treeChanged} event`);
+            throw new UsageError(`${action} is forbidden during a change event callback`);
         }
     }
     /**
@@ -1110,33 +1116,6 @@ class EditLock {
         this.locked = false;
     }
 }
-/**
- * Keeps track of all new forks created until the returned function is invoked, which will dispose all of those for.
- * The returned function may only be called once.
- *
- * @param checkout - The tree checkout for which you want to monitor forks for disposal.
- * @returns a function which can be called to dispose all of the tracked forks.
- */
-function trackForksForDisposal(checkout) {
-    const forks = new Set();
-    const onDisposeUnSubscribes = [];
-    const onForkUnSubscribe = onForkTransitive(checkout, (fork) => {
-        forks.add(fork);
-        onDisposeUnSubscribes.push(fork.events.on("dispose", () => forks.delete(fork)));
-    });
-    let disposed = false;
-    return () => {
-        assert(!disposed, 0xaa9 /* Forks may only be disposed once */);
-        for (const fork of forks) {
-            fork.dispose();
-        }
-        for (const unsubscribe of onDisposeUnSubscribes) {
-            unsubscribe();
-        }
-        onForkUnSubscribe();
-        disposed = true;
-    };
-}
 function verboseFromCursor(reader, schema) {
     const fields = customFromCursorStored(reader, schema, verboseFromCursor);
     const nodeSchema = schema.get(reader.type) ?? fail(0xac9 /* missing schema for type in cursor */);