Improve applySerializedChange to support cross-session usage and transactions

packages/dds/tree/src/core/rebase/types.ts

@@ -210,7 +210,6 @@ export interface LocalChangeMetadata extends CommitMetadata {
 	 * Returns a serializable object that encodes the change.
 	 * @remarks This is only available for local changes.
 	 * This change object can be {@link TreeBranchAlpha.applyChange | applied to another branch} in the same state as the one which generated it.
-	 * The change object must be applied to a SharedTree with the same IdCompressor session ID as it was created from.
 	 * @privateRemarks
 	 * This is a `SerializedChange` from treeCheckout.ts.
 	 */

packages/dds/tree/src/shared-tree-core/branch.ts

@@ -124,7 +124,7 @@ export class SharedTreeBranch<TEditor extends ChangeFamilyEditor, TChange> {
 	public constructor(
 		private head: GraphCommit<TChange>,
 		public readonly changeFamily: ChangeFamily<TEditor, TChange>,
-		private readonly mintRevisionTag: () => RevisionTag,
+		public readonly mintRevisionTag: () => RevisionTag,
 		private readonly branchTrimmer?: Listenable<BranchTrimmingEvents>,
 		private readonly telemetryEventBatcher?: TelemetryEventBatcher<
 			keyof RebaseStatsWithDuration

packages/dds/tree/src/shared-tree/treeCheckout.ts

@@ -63,6 +63,7 @@ import {
 	type TaggedChange,
 } from "../core/index.js";
 import {
+	DefaultRevisionReplacer,
 	type FieldBatchCodec,
 	type TreeCompressionStrategy,
 	allowsRepoSuperset,
@@ -715,6 +716,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 							idCompressor: this.idCompressor,
 							originatorId: this.idCompressor.localSessionId,
 							revision,
+							schema: undefined, // By not passing the schema, we avoid compressing identifiers in identifier fields
 						};
 						const encodedChange = this.changeFamily.codecs.resolve(4).encode(change, context);
 
@@ -775,19 +777,26 @@ export class TreeCheckout implements ITreeCheckoutFork {
 			throw new UsageError(`Cannot apply change. Invalid serialized change format.`);
 		}
 		const { revision, originatorId, change } = serializedChange;
-		if (originatorId !== this.idCompressor.localSessionId) {
-			throw new UsageError(
-				`Cannot apply change. A serialized changed must be applied to the same SharedTree as it was created from.`,
-			);
-		}
 		const context: ChangeEncodingContext = {
 			idCompressor: this.idCompressor,
-			originatorId: this.idCompressor.localSessionId,
+			originatorId,
 			revision,
 		};
 		const decodedChange = this.changeFamily.codecs.resolve(4).decode(change, context);
-		// Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.
-		this.#transaction.branch.apply(tagChange(decodedChange, revision));
+
+		// The change's revision may have been produced by an IdCompressor that overlaps or is otherwise incompatible with ours.
+		// Replace the revision to avoid any ID collisions in the changeset - every application of a serialized changed will result in a different revision.
+		// This means that applying the same serialized change twice will result in its insertions/mutations being performed twice.
+		// The second change will not be deduplicated with the first by the rebaser, as would be the case if they were truly the same change with the same revision.
+		const newRevision = this.#transaction.activeBranch.mintRevisionTag();
+		const newChange = this.changeFamily.rebaser.changeRevision(
+			decodedChange,
+			new DefaultRevisionReplacer(
+				newRevision,
+				this.changeFamily.rebaser.getRevisions(decodedChange),
+			),
+		);
+		this.#transaction.activeBranch.apply(tagChange(newChange, newRevision));
 	}
 
 	// Revision is the revision of the commit, if any, which caused this change.

packages/dds/tree/src/simple-tree/api/tree.ts

@@ -332,12 +332,11 @@ export interface TreeBranchAlpha extends TreeBranch, TreeContextAlpha {
 	 * Apply a serialized change to this branch.
 	 * @param change - the change to apply.
 	 * Changes are acquired via `getChange` in a branch's {@link TreeBranchEvents.changed | "changed"} event.
-	 * @remarks Changes may only be applied to a SharedTree with the same IdCompressor instance and branch state from which they were generated.
-	 * They may be created by one branch and applied to another, but only if both branches share the same history at the time of creation and application.
+	 * @remarks Changes may only be applied to a SharedTree with the same branch state from which they were generated.
+	 * They may be created by one branch and applied to another, but only if both branches share the same history at the time of creation and application, respectively.
+	 * The two branches may use different IdCompressor instances (e.g. across different runtimes or processes).
 	 *
-	 * @privateRemarks
-	 * TODO: This method will support applying changes from different IdCompressor instances as long as they have the same local session ID.
-	 * Update the tests and docs to match when that is done.
+	 * Applying changes is not idempotent, that is, the same serialized change applied twice will have two effects - it will not be deduplicated.
 	 */
 	applyChange(change: JsonCompatibleReadOnly): void;
 }

packages/dds/tree/src/test/simple-tree/api/tree.spec.ts

@@ -309,7 +309,7 @@ describe("simple-tree tree", () => {
 			assert.equal(viewA.root, 4);
 		});
 
-		it("fail to apply to a branch in another session", () => {
+		it("can be applied to a view with a different session", () => {
 			const config = new TreeViewConfiguration({ schema: schema.number });
 			const viewA = getView(config);
 			viewA.initialize(3);
@@ -323,10 +323,9 @@ describe("simple-tree tree", () => {
 			});
 			viewA.root = 4;
 
-			const c = change ?? assert.fail("change not captured");
-			assert.throws(() => {
-				viewB.applyChange(c);
-			}, /cannot apply change.*same sharedtree/i);
+			assert(change !== undefined);
+			viewB.applyChange(change);
+			assert.equal(viewB.root, 4);
 		});
 
 		it("error if malformed", () => {
@@ -383,7 +382,33 @@ describe("simple-tree tree", () => {
 			assert.equal(viewA.root, 4);
 		});
 
-		it("apply before transactions", () => {
+		it("applying the same change twice is not idempotent", () => {
+			const sf = new SchemaFactory("test");
+			class List extends sf.array("List", sf.number) {}
+			const config = new TreeViewConfiguration({ schema: List });
+			const viewA = getView(config);
+			viewA.initialize([1, 2, 3]);
+			const viewB = viewA.fork();
+
+			let change: JsonCompatibleReadOnly | undefined;
+			viewB.events.on("changed", (metadata) => {
+				assert(metadata.isLocal);
+				change = metadata.getChange();
+			});
+
+			// Insert a node on viewB
+			viewB.root.insertAtEnd(4);
+			assert(change !== undefined);
+
+			// Apply the same serialized change twice to viewA
+			viewA.applyChange(change);
+			viewA.applyChange(change);
+
+			// Each application should produce a distinct effect - the node is inserted twice
+			assert.deepEqual([...viewA.root], [1, 2, 3, 4, 4]);
+		});
+
+		it("non-transaction change can be applied inside a transaction", () => {
 			const config = new TreeViewConfiguration({ schema: schema.number });
 			const viewA = getView(config);
 			viewA.initialize(3);
@@ -395,16 +420,129 @@ describe("simple-tree tree", () => {
 				change = metadata.getChange();
 			});
 
+			// Make a non-transaction change on viewB
 			viewB.root = 4;
+			assert(change !== undefined);
+
+			// Apply that non-transaction change inside a transaction on viewA
+			const capturedChange = change;
 			viewA.runTransaction(() => {
-				viewA.root = 5;
-				assert(change !== undefined);
-				// Even though the serialized change (= 4) is applied _after_ the transaction change (= 5),
-				// it is considered a change external to the transaction and so will be applied before the transaction changes,
-				// as is the general policy for external changes applied during a transaction.
-				viewA.applyChange(change);
+				viewA.applyChange(capturedChange);
 			});
-			assert.equal(viewA.root, 5);
+			assert.equal(viewA.root, 4);
+		});
+
+		it("multiple non-transaction changes can be applied together in a transaction", () => {
+			const sf = new SchemaFactory("test");
+			class List extends sf.array("List", sf.number) {}
+			const config = new TreeViewConfiguration({ schema: List });
+			const viewA = getView(config);
+			viewA.initialize([1, 2, 3]);
+			const viewB = viewA.fork();
+
+			const changes: JsonCompatibleReadOnly[] = [];
+			viewB.events.on("changed", (metadata) => {
+				assert(metadata.isLocal);
+				changes.push(metadata.getChange());
+			});
+
+			// Make two separate non-transaction changes on viewB
+			viewB.root.insertAtEnd(4);
+			viewB.root.insertAtEnd(5);
+			assert.equal(changes.length, 2);
+
+			// Apply both non-transaction changes together inside a single transaction on viewA
+			viewA.runTransaction(() => {
+				viewA.applyChange(changes[0]);
+				viewA.applyChange(changes[1]);
+			});
+			assert.deepEqual([...viewA.root], [1, 2, 3, 4, 5]);
+		});
+
+		it("applied change is rolled back when transaction is aborted", () => {
+			const config = new TreeViewConfiguration({ schema: schema.number });
+			const viewA = getView(config);
+			viewA.initialize(3);
+			const viewB = viewA.fork();
+
+			let change: JsonCompatibleReadOnly | undefined;
+			viewB.events.on("changed", (metadata) => {
+				assert(metadata.isLocal);
+				change = metadata.getChange();
+			});
+
+			viewB.root = 4;
+			assert(change !== undefined);
+
+			const capturedChange = change;
+			Tree.runTransaction(viewA, () => {
+				viewA.applyChange(capturedChange);
+				assert.equal(viewA.root, 4);
+				return Tree.runTransaction.rollback;
+			});
+			// The serialized change should be rolled back along with the transaction
+			assert.equal(viewA.root, 3);
+		});
+
+		it("can apply a change with an identifier field build to a view with a different id compressor", () => {
+			const sf = new SchemaFactory("test");
+			class HasId extends sf.object("HasId", { id: sf.identifier }) {}
+			const config = new TreeViewConfiguration({
+				schema: SchemaFactory.optional(HasId),
+			});
+
+			// Two independent views get different id compressors with different sessions
+			const viewA = getView(config);
+			viewA.initialize(undefined);
+			const viewB = getView(config);
+			viewB.initialize(undefined);
+
+			let change: JsonCompatibleReadOnly | undefined;
+			viewA.events.on("changed", (metadata) => {
+				if (metadata.isLocal) {
+					change = metadata.getChange();
+				}
+			});
+
+			// Insert a node with a default identifier on viewA
+			viewA.root = new HasId({ id: undefined });
+			assert(change !== undefined);
+			const identifierOnA = viewA.root.id;
+
+			// Apply the serialized change to viewB (different compressor instance and session)
+			viewB.applyChange(change);
+			assert(viewB.root !== undefined);
+			assert.equal(viewB.root.id, identifierOnA);
+		});
+
+		it("each application gets a unique revision", () => {
+			const config = new TreeViewConfiguration({ schema: schema.number });
+			const viewA = getView(config);
+			viewA.initialize(3);
+			const viewB = viewA.fork();
+
+			let change: JsonCompatibleReadOnly | undefined;
+			viewB.events.on("changed", (metadata) => {
+				assert(metadata.isLocal);
+				change = metadata.getChange();
+			});
+
+			viewB.root = 4;
+			assert(change !== undefined);
+
+			// Track the changes applied to viewA
+			const appliedChanges: JsonCompatibleReadOnly[] = [];
+			viewA.events.on("changed", (metadata) => {
+				if (metadata.isLocal) {
+					appliedChanges.push(metadata.getChange());
+				}
+			});
+
+			viewA.applyChange(change);
+			viewA.applyChange(change);
+
+			// Each application should produce a separate change event
+			assert.equal(appliedChanges.length, 2);
 		});
 	});
 });