@fluid-experimental/tree 0.59.4002 → 1.0.2

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,25 +24,15 @@ 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 {
-    /**
-     * 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;
+    constructor(...args) {
+        this.args = args;
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
@@ -69,15 +59,21 @@ export class SharedTreeFactory {
      * @param runtime - data store runtime that owns the new SharedTree
      * @param id - optional name for the SharedTree
      */
-    create(runtime, id, expensiveValidation = false) {
-        this.expensiveValidation = expensiveValidation;
+    create(runtime, id) {
         const sharedTree = this.createSharedTree(runtime, id);
         sharedTree.initializeLocal();
         return sharedTree;
     }
     createSharedTree(runtime, id) {
-        const sharedTree = new SharedTree(runtime, id, this.writeFormat, this.summarizeHistory, this.expensiveValidation);
-        return sharedTree;
+        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');
+        }
     }
 }
 /**
@@ -106,20 +102,9 @@ const sharedTreeTelemetryProperties = { all: { isSharedTreeEvent: true } };
  * @public
  */
 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 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);
+    constructor(runtime, id, writeFormat, options = {}) {
+        super(id, runtime, SharedTreeFactory.Attributes, 'fluid_sharedTree_');
         this.writeFormat = writeFormat;
-        this.expensiveValidation = expensiveValidation;
-        this.idCompressor = new IdCompressor(createSessionId(), reservedIdCount);
         this.idNormalizer = {
             tree: this,
             get localSessionId() {
@@ -162,8 +147,9 @@ export class SharedTree extends SharedObject {
                 }
             }
         };
-        this.summarizeHistory = summarizeHistory === false ? false : true;
-        this.uploadEditChunks = summarizeHistory === false ? false : summarizeHistory.uploadEditChunks;
+        const historyPolicy = this.getHistoryPolicy(options);
+        this.summarizeHistory = historyPolicy.summarizeHistory;
+        this.uploadEditChunks = historyPolicy.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
@@ -175,11 +161,12 @@ 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, // TODO: Attribution info
-        this.processEditResult, this.processSequencedEditResult, WriteFormat.v0_1_1);
+        }, undefined, this.idCompressor, 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);
@@ -191,31 +178,39 @@ export class SharedTree extends SharedObject {
     static create(runtime, id) {
         return runtime.createChannel(id, SharedTreeFactory.Type);
     }
-    /**
-     * 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) {
+    static getFactory(...args) {
+        const [writeFormat] = args;
         // 	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);
+        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;
+            }
+        }
     }
     /**
      * Viewer for trees defined by editLog. This allows access to views of the tree at different revisions (various points in time).
@@ -223,6 +218,27 @@ 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;
     }
@@ -319,6 +335,25 @@ 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
@@ -465,7 +500,7 @@ export class SharedTree extends SharedObject {
         let convertedSummary;
         switch (loadedSummaryVersion) {
             case WriteFormat.v0_0_2:
-                convertedSummary = this.encoder_0_0_2.decodeSummary(summary);
+                convertedSummary = this.encoder_0_0_2.decodeSummary(summary, this.attributionId);
                 break;
             case WriteFormat.v0_1_1: {
                 const typedSummary = summary;
@@ -476,7 +511,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); // TODO:#461: pass attribution info
+                convertedSummary = this.encoder_0_1_1.decodeSummary(summary, this.attributionId);
                 break;
             }
             default:
@@ -764,7 +799,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); // TODO: attribution info
+        const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount, this.attributionId);
         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
@@ -778,7 +813,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); // TODO: attribution info
+        const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount);
         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