@fluid-experimental/tree 0.58.3000-61081 → 0.59.2000-61729

package/lib/SharedTree.js

@@ -21,7 +21,6 @@ import { RevisionView } from './RevisionView';
 import { SharedTreeEncoder_0_0_2, SharedTreeEncoder_0_1_1 } from './SharedTreeEncoder';
 import { revert } from './HistoryEditFactory';
 import { ChangeType } from './ChangeTypes';
-import { TransactionInternal } from './TransactionInternal';
 import { IdCompressor, createSessionId } from './id-compressor';
 import { convertEditIds } from './IdConversion';
 import { MutableStringInterner } from './StringInterner';
@@ -33,13 +32,10 @@ import { MutableStringInterner } from './StringInterner';
 export class SharedTreeFactory {
     /**
      * Get a factory for SharedTree to register with the data store.
-     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
-     * This format may be updated to a newer (supported) version at runtime if a collaborating shared-tree
-     * that was initialized with a newer write version connects to the session. Care must be taken when changing this value,
-     * as a staged rollout must have occurred such that all collaborating clients must have the code to read at least the version
-     * written.
+     * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in. See [the write format
+     * documentation](../docs/Write-Format.md) for more information.
      * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
-     * See docs/Breaking-Change-Migration for more details on this scheme.
+     * See the [breaking change migration documentation](docs/Breaking-Change-Migration) for more details on this scheme.
      * @param expensiveValidation - Enables expensive asserts on SharedTree.
      * @returns A factory that creates `SharedTree`s and loads them from storage.
      */
@@ -106,7 +102,7 @@ const snapshotFileName = 'header';
 const sortedWriteVersions = [WriteFormat.v0_0_2, WriteFormat.v0_1_1];
 const sharedTreeTelemetryProperties = { all: { isSharedTreeEvent: true } };
 /**
- * A distributed tree.
+ * A [distributed tree](../Readme.md).
  * @public
  */
 export class SharedTree extends SharedObject {
@@ -114,7 +110,8 @@ export class SharedTree extends SharedObject {
      * Create a new SharedTreeFactory.
      * @param runtime - The runtime the SharedTree will be associated with
      * @param id - Unique ID for the SharedTree
-     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
+     * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in. See [the write format
+     * documentation](../docs/Write-Format.md) for more information.
      * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
      * @param expensiveValidation - Enable expensive asserts.
      */
@@ -148,7 +145,6 @@ export class SharedTree extends SharedObject {
             };
             this.emit(SharedTreeEvent.SequencedEditApplied, eventArguments);
         };
-        this.transactionFactory = TransactionInternal.factory;
         /**
          * Re-computes currentIsOldest and emits an event if it has changed.
          * TODO:#55900: Get rid of copy-pasted OldestClientObserver code
@@ -198,6 +194,7 @@ export class SharedTree extends SharedObject {
     /**
      * Get a factory for SharedTree to register with the data store.
      * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
+     *
      * On 0.1.1 documents, due to current code limitations, this parameter is only impactful for newly created documents.
      * `SharedTree`s which load existing documents will summarize history if and only if the loaded summary included history.
      *
@@ -205,14 +202,19 @@ export class SharedTree extends SharedObject {
      * In the future we may allow modification of whether or not a particular document saves history, but only via a consensus mechanism.
      * See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
      * See docs/Breaking-Change-Migration for more details on the consensus scheme.
-     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
+     * @param writeFormat - Determines the format version the SharedTree will write ops and summaries in.
      * This format may be updated to a newer (supported) version at runtime if a collaborating shared-tree
      * that was initialized with a newer write version connects to the session. Care must be taken when changing this value,
      * as a staged rollout must of occurred such that all collaborating clients must have the code to read at least the version
      * written.
+     * See [the write format documentation](../docs/Write-Format.md) for more information.
      * @returns A factory that creates `SharedTree`s and loads them from storage.
      */
     static getFactory(writeFormat, summarizeHistory = false) {
+        // 	On 0.1.1 documents, due to current code limitations, all clients MUST agree on the value of `summarizeHistory`.
+        //  Note that this means staged rollout changing this value should not be attempted.
+        //  It is possible to update shared-tree to correctly handle such a staged rollout, but that hasn't been implemented.
+        //  See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
         return new SharedTreeFactory(writeFormat, summarizeHistory);
     }
     /**
@@ -260,27 +262,60 @@ export class SharedTree extends SharedObject {
         return this.logViewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
     }
     /**
-     * {@inheritdoc NodeIdGenerator.generateNodeId}
+     * Generates a node identifier.
+     * The returned IDs may be used as the identifier of a node in the SharedTree.
+     * `NodeId`s are *always* unique and stable within the scope of the tree and session that generated them. They are *not* unique within
+     * a Fluid container, and *cannot* be compared across instances of a SharedTree. They are *not* stable across sessions/lifetimes of a
+     * SharedTree, and *cannot* be persisted (e.g. stored in payloads, uploaded in blobs, etc.). If stable persistence is needed,
+     * NodeIdConverter.convertToStableNodeId may be used to return a corresponding UUID that is globally unique and stable.
+     * @param override - if supplied, calls to `convertToStableNodeId` using the returned node ID will return the override instead of
+     * the UUID. Calls to `generateNodeId` with the same override always return the same ID. Performance note: passing an override string
+     * incurs a storage cost that is significantly higher that a node ID without one, and should be avoided if possible.
      * @public
      */
     generateNodeId(override) {
         return this.idCompressor.generateCompressedId(override);
     }
-    /** {@inheritdoc NodeIdConverter.convertToStableNodeId} */
+    /**
+     * Given a NodeId, returns the corresponding stable ID or throws if the supplied node ID was not generated with this tree (`NodeId`s
+     * may not be used across SharedTree instances, see `generateNodeId` for more).
+     * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).
+     * The result is safe to persist and re-use across `SharedTree` instances, unlike `NodeId`.
+     * @public
+     */
     convertToStableNodeId(id) {
         var _a;
         return (_a = this.idCompressor.tryDecompress(id)) !== null && _a !== void 0 ? _a : fail('Node id is not known to this SharedTree');
     }
-    /** {@inheritdoc NodeIdConverter.tryConvertToStableNodeId} */
+    /**
+     * Given a NodeId, attempt to return the corresponding stable ID.
+     * The returned value will be a UUID, unless the creation of `id` used an override string (see `generateNodeId` for more).
+     * The returned stable ID is undefined if `id` was never created with this SharedTree. If a stable ID is returned, this does not imply
+     * that there is a node with `id` in the current revision of the tree, only that `id` was at some point generated by some instance of
+     * this tree.
+     * @public
+     */
     tryConvertToStableNodeId(id) {
         return this.idCompressor.tryDecompress(id);
     }
-    /** {@inheritdoc NodeIdConverter.convertToNodeId} */
+    /**
+     * Given a stable ID, return the corresponding NodeId or throws if the supplied stable ID was never generated with this tree, either
+     * as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.
+     * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that
+     * `id` was at some point generated by an instance of this SharedTree.
+     * @public
+     */
     convertToNodeId(id) {
         var _a;
         return ((_a = this.idCompressor.tryRecompress(id)) !== null && _a !== void 0 ? _a : fail('Stable node id is not known to this SharedTree'));
     }
-    /** {@inheritdoc NodeIdConverter.tryConvertToNodeId} */
+    /**
+     * Given a stable ID, return the corresponding NodeId or return undefined if the supplied stable ID was never generated with this tree,
+     * either as a UUID corresponding to a `NodeId` or as an override passed to `generateNodeId`.
+     * If a stable ID is returned, this does not imply that there is a node with `id` in the current revision of the tree, only that
+     * `id` was at some point generated by an instance of this SharedTree.
+     * @public
+     */
     tryConvertToNodeId(id) {
         return this.idCompressor.tryRecompress(id);
     }
@@ -524,7 +559,7 @@ export class SharedTree extends SharedObject {
             // TODO:#47830: Store multiple checkpoints in summary.
             knownRevisions = [[editLog.length, { view: currentView }]];
         }
-        const logViewer = new CachingLogViewer(editLog, RevisionView.fromTree(initialTree, this), knownRevisions, this.expensiveValidation, editStatusCallback, sequencedEditResultCallback, this.transactionFactory, 0);
+        const logViewer = new CachingLogViewer(editLog, RevisionView.fromTree(initialTree, this), knownRevisions, this.expensiveValidation, editStatusCallback, sequencedEditResultCallback, 0);
         this.editLog = editLog;
         this.cachingLogViewer = logViewer;
         return { editLog, cachingLogViewer: logViewer };
@@ -547,7 +582,7 @@ export class SharedTree extends SharedObject {
         }
     }
     /**
-     * Compares this shared tree to another for equality. Should only be used for correctness testing.
+     * Compares this shared tree to another for equality. Should only be used for internal correctness testing.
      *
      * Equality means that the histories as captured by the EditLogs are equivalent.
      *
@@ -615,7 +650,9 @@ export class SharedTree extends SharedObject {
                 }
                 // TODO: This cast can be removed on typescript 4.6
                 const edit = this.parseSequencedEdit(op);
-                this.internStringsFromEdit(edit);
+                if (op.version === WriteFormat.v0_1_1) {
+                    this.internStringsFromEdit(edit);
+                }
                 this.processSequencedEdit(edit, typedMessage);
             }
         }
@@ -735,9 +772,8 @@ export class SharedTree extends SharedObject {
         }
     }
     upgradeFrom_0_0_2_to_0_1_1() {
-        for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
-            this.internStringsFromEdit(this.editsInternal.getEditInSessionAtIndex(i));
-        }
+        // Reset the string interner, re-populate only with information that there is consensus on
+        this.interner = new MutableStringInterner([initialTree.definition]);
         const oldIdCompressor = this.idCompressor;
         // Create the IdCompressor that will be used after the upgrade
         const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount); // TODO: attribution info
@@ -760,12 +796,21 @@ export class SharedTree extends SharedObject {
             // All clients have the full history, and can therefore all "generate" the same final IDs for every ID in the history
             // via the ghost compressor.
             unifyHistoricalIds(ghostContext);
+            // The same logic applies to string interning, so intern all the strings in the history (superset of those in the current view)
+            for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
+                this.internStringsFromEdit(this.editsInternal.getEditInSessionAtIndex(i));
+            }
         }
         else {
             // Clients do not have the full history, but all share the same current view (sequenced). They can all finalize the same final
             // IDs for every ID in the view via the ghost compressor.
+            // The same logic applies for the string interner.
             for (const node of this.logViewer.getRevisionViewInSession(this.editLog.numberOfSequencedEdits)) {
                 ghostContext.generateNodeId(this.convertToStableNodeId(node.identifier));
+                this.interner.getOrCreateInternedId(node.definition);
+                for (const label of [...node.traits.keys()].sort()) {
+                    this.interner.getOrCreateInternedId(label);
+                }
             }
             // Every node in this client's history can simply be generated in the new compressor as well, preserving the UUID
             unifyHistoricalIds(newContext);
@@ -774,13 +819,8 @@ export class SharedTree extends SharedObject {
         newIdCompressor.finalizeCreationRange(ghostIdCompressor.takeNextCreationRange());
         this.idCompressor = newIdCompressor;
     }
-    /**
-     * Add an `Edit` directly.
-     * External users should use one of the more specialized functions, like applyEdit which handles constructing the actual `Edit` object.
-     * This is exposed as it is useful for testing, particularly with invalid and malformed Edits.
-     * @internal
-     */
-    applyEdit(...changes) {
+    applyEdit(headOrChanges, ...tail) {
+        const changes = Array.isArray(headOrChanges) ? headOrChanges : [headOrChanges, ...tail];
         const id = newEditId();
         const internalEdit = {
             id,
@@ -791,6 +831,10 @@ export class SharedTree extends SharedObject {
         return internalEdit;
     }
     /**
+     * Applies a set of internal changes to this tree. The result will be reflected in `SharedTree.currentView`.
+     * External users should use one of the more specialized functions, like `applyEdit` which handles constructing the actual `Edit`
+     * and uses public Change types.
+     * This is exposed for internal use only.
      * @internal
      */
     applyEditInternal(editOrChanges) {
@@ -807,7 +851,8 @@ export class SharedTree extends SharedObject {
         return edit;
     }
     /**
-     * Given a newly constructed edit, add any necessary metadata
+     * Converts a public Change type to an internal representation.
+     * This is exposed for internal use only.
      * @internal
      */
     internalizeChange(change) {