@fluid-experimental/tree 0.59.3000 → 0.59.3003

package/lib/SharedTree.js

@@ -8,7 +8,7 @@ import { createSingleBlobSummary, serializeHandles, SharedObject, } from '@fluid
 import { ChildLogger, PerformanceEvent } from '@fluidframework/telemetry-utils';
 import { assert, assertNotUndefined, fail, copyPropertyIfDefined, noop } from './Common';
 import { EditLog, getNumberOfHandlesFromEditLogSummary } from './EditLog';
-import { isDetachedSequenceId, } from './Identifiers';
+import { isDetachedSequenceId } from './Identifiers';
 import { initialTree } from './InitialTree';
 import { CachingLogViewer, } from './LogViewer';
 import { deserialize, getSummaryStatistics } from './SummaryBackCompatibility';
@@ -24,15 +24,25 @@ import { ChangeType } from './ChangeTypes';
 import { IdCompressor, createSessionId } from './id-compressor';
 import { convertEditIds } from './IdConversion';
 import { MutableStringInterner } from './StringInterner';
-import { nilUuid } from './UuidUtilities';
 /**
  * Factory for SharedTree.
  * Includes history in the summary.
  * @public
  */
 export class SharedTreeFactory {
-    constructor(...args) {
-        this.args = args;
+    /**
+     * Get a factory for SharedTree to register with the data store.
+     * @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 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.
+     */
+    constructor(writeFormat, summarizeHistory = false, expensiveValidation = false) {
+        this.writeFormat = writeFormat;
+        this.summarizeHistory = summarizeHistory;
+        this.expensiveValidation = expensiveValidation;
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
@@ -59,21 +69,15 @@ export class SharedTreeFactory {
      * @param runtime - data store runtime that owns the new SharedTree
      * @param id - optional name for the SharedTree
      */
-    create(runtime, id) {
+    create(runtime, id, expensiveValidation = false) {
+        this.expensiveValidation = expensiveValidation;
         const sharedTree = this.createSharedTree(runtime, id);
         sharedTree.initializeLocal();
         return sharedTree;
     }
     createSharedTree(runtime, id) {
-        const [writeFormat] = this.args;
-        switch (writeFormat) {
-            case WriteFormat.v0_0_2:
-                return new SharedTree(runtime, id, ...this.args);
-            case WriteFormat.v0_1_1:
-                return new SharedTree(runtime, id, ...this.args);
-            default:
-                fail('Unknown write format');
-        }
+        const sharedTree = new SharedTree(runtime, id, this.writeFormat, this.summarizeHistory, this.expensiveValidation);
+        return sharedTree;
     }
 }
 /**
@@ -102,9 +106,20 @@ const sharedTreeTelemetryProperties = { all: { isSharedTreeEvent: true } };
  * @public
  */
 export class SharedTree extends SharedObject {
-    constructor(runtime, id, writeFormat, options = {}) {
+    /**
+     * 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 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.
+     */
+    constructor(runtime, id, writeFormat, summarizeHistory = false, expensiveValidation = false) {
         super(id, runtime, SharedTreeFactory.Attributes);
         this.writeFormat = writeFormat;
+        this.expensiveValidation = expensiveValidation;
+        this.idCompressor = new IdCompressor(createSessionId(), reservedIdCount);
         this.idNormalizer = {
             tree: this,
             get localSessionId() {
@@ -147,9 +162,8 @@ export class SharedTree extends SharedObject {
                 }
             }
         };
-        const historyPolicy = this.getHistoryPolicy(options);
-        this.summarizeHistory = historyPolicy.summarizeHistory;
-        this.uploadEditChunks = historyPolicy.uploadEditChunks;
+        this.summarizeHistory = summarizeHistory === false ? false : true;
+        this.uploadEditChunks = summarizeHistory === false ? false : summarizeHistory.uploadEditChunks;
         // This code is somewhat duplicated from OldestClientObserver because it currently depends on the container runtime
         // which SharedTree does not have access to.
         // TODO:#55900: Get rid of copy-pasted OldestClientObserver code
@@ -161,12 +175,11 @@ export class SharedTree extends SharedObject {
         runtime.on('disconnected', this.updateOldest);
         this.logger = ChildLogger.create(runtime.logger, 'SharedTree', sharedTreeTelemetryProperties);
         this.sequencedEditAppliedLogger = ChildLogger.create(this.logger, 'SequencedEditApplied', sharedTreeTelemetryProperties);
-        const attributionId = options.attributionId;
-        this.idCompressor = new IdCompressor(createSessionId(), reservedIdCount, attributionId);
         const { editLog, cachingLogViewer } = this.initializeNewEditLogFromSummary({
             editChunks: [],
             editIds: [],
-        }, undefined, this.idCompressor, this.processEditResult, this.processSequencedEditResult, WriteFormat.v0_1_1);
+        }, undefined, this.idCompressor, // TODO: Attribution info
+        this.processEditResult, this.processSequencedEditResult, WriteFormat.v0_1_1);
         this.editLog = editLog;
         this.cachingLogViewer = cachingLogViewer;
         this.encoder_0_0_2 = new SharedTreeEncoder_0_0_2(this.summarizeHistory);
@@ -178,39 +191,31 @@ export class SharedTree extends SharedObject {
     static create(runtime, id) {
         return runtime.createChannel(id, SharedTreeFactory.Type);
     }
-    static getFactory(...args) {
-        const [writeFormat] = args;
+    /**
+     * 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.
+     *
+     * The technical limitations here relate to clients with mixed versions collaborating.
+     * 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 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.
-        switch (writeFormat) {
-            case WriteFormat.v0_0_2:
-                return new SharedTreeFactory(...args);
-            case WriteFormat.v0_1_1:
-                return new SharedTreeFactory(...args);
-            default:
-                fail('Unknown write format');
-        }
-    }
-    /**
-     * The UUID used for attribution of nodes created by this SharedTree. All shared trees with a write format of 0.1.1 or
-     * greater have a unique attribution ID which may be configured in the constructor. All other shared trees (i.e. those
-     * with a write format of 0.0.2) use the nil UUID as their attribution ID.
-     * @public
-     */
-    get attributionId() {
-        switch (this.writeFormat) {
-            case WriteFormat.v0_0_2:
-                return nilUuid;
-            default: {
-                const { attributionId } = this.idCompressor;
-                if (attributionId === ghostSessionId) {
-                    return nilUuid;
-                }
-                return attributionId;
-            }
-        }
+        return new SharedTreeFactory(writeFormat, summarizeHistory);
     }
     /**
      * Viewer for trees defined by editLog. This allows access to views of the tree at different revisions (various points in time).
@@ -218,27 +223,6 @@ export class SharedTree extends SharedObject {
     get logViewer() {
         return this.cachingLogViewer;
     }
-    getHistoryPolicy(options) {
-        var _a;
-        const noCompatOptions = options;
-        if (typeof noCompatOptions.summarizeHistory === 'object') {
-            return {
-                summarizeHistory: true,
-                uploadEditChunks: noCompatOptions.summarizeHistory.uploadEditChunks,
-            };
-        }
-        else {
-            return {
-                summarizeHistory: (_a = noCompatOptions.summarizeHistory) !== null && _a !== void 0 ? _a : false,
-                uploadEditChunks: false,
-            };
-        }
-    }
-    /**
-     * The write format version currently used by this `SharedTree`. This is always initialized to the write format
-     * passed to the tree's constructor, but it may automatically upgrade over time (e.g. when connected to another
-     * SharedTree with a higher write format, or when loading a summary with a higher write format).
-     */
     getWriteFormat() {
         return this.writeFormat;
     }
@@ -335,25 +319,6 @@ export class SharedTree extends SharedObject {
     tryConvertToNodeId(id) {
         return this.idCompressor.tryRecompress(id);
     }
-    /**
-     * Returns the attribution ID associated with the SharedTree that generated the given node ID. This is generally only useful for clients
-     * with a write format of 0.1.1 or greater since older clients cannot be given an attribution ID and will always use the default
-     * `attributionId` of the tree.
-     * @public
-     */
-    attributeNodeId(id) {
-        switch (this.writeFormat) {
-            case WriteFormat.v0_0_2:
-                return nilUuid;
-            default: {
-                const attributionId = this.idCompressor.attributeId(id);
-                if (attributionId === ghostSessionId) {
-                    return nilUuid;
-                }
-                return attributionId;
-            }
-        }
-    }
     /**
      * @returns the edit history of the tree.
      * @public
@@ -500,7 +465,7 @@ export class SharedTree extends SharedObject {
         let convertedSummary;
         switch (loadedSummaryVersion) {
             case WriteFormat.v0_0_2:
-                convertedSummary = this.encoder_0_0_2.decodeSummary(summary, this.attributionId);
+                convertedSummary = this.encoder_0_0_2.decodeSummary(summary);
                 break;
             case WriteFormat.v0_1_1: {
                 const typedSummary = summary;
@@ -511,7 +476,7 @@ export class SharedTree extends SharedObject {
                     this.uploadEditChunks = loadedSummaryIncludesHistory;
                     this.encoder_0_1_1 = new SharedTreeEncoder_0_1_1(this.summarizeHistory);
                 }
-                convertedSummary = this.encoder_0_1_1.decodeSummary(summary, this.attributionId);
+                convertedSummary = this.encoder_0_1_1.decodeSummary(summary); // TODO:#461: pass attribution info
                 break;
             }
             default:
@@ -799,7 +764,7 @@ export class SharedTree extends SharedObject {
         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, this.attributionId);
+        const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount); // TODO: attribution info
         const newContext = getNodeIdContext(newIdCompressor);
         // Generate all local IDs in the new compressor that were in the old compressor and preserve their UUIDs.
         // This will allow the client to continue to use local IDs that were allocated pre-upgrade
@@ -813,7 +778,7 @@ export class SharedTree extends SharedObject {
             }
         };
         // Construct a temporary "ghost" compressor which is used to generate final IDs that will be consistent across all upgrading clients
-        const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount);
+        const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount); // TODO: attribution info
         const ghostContext = getNodeIdContext(ghostIdCompressor);
         if (this.summarizeHistory) {
             // All clients have the full history, and can therefore all "generate" the same final IDs for every ID in the history