@fluidframework/tree 2.113.0-411909 → 2.114.0

package/src/feature-libraries/modular-schema/invert.ts

@@ -0,0 +1,338 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import {
+	revisionMetadataSourceFromInfo,
+	type ChangeAtomId,
+	type ChangesetLocalId,
+	type FieldKindIdentifier,
+	type RevisionInfo,
+	type RevisionMetadataSource,
+	type RevisionTag,
+	type TaggedChange,
+	type TreeChunk,
+} from "../../core/index.js";
+import { brand, idAllocatorFromMaxId, type IdAllocator } from "../../util/index.js";
+import {
+	newChangeAtomIdBTree,
+	setInChangeAtomIdMap,
+	type ChangeAtomIdBTree,
+} from "../changeAtomIdBTree.js";
+import {
+	newCrossFieldKeyTable,
+	type CrossFieldKeyTable,
+	type FieldChange,
+	type FieldChangeMap,
+	type FieldId,
+	type ModularChangeset,
+	type NodeChangeset,
+	type NodeId,
+} from "./modularChangeTypes.js";
+import {
+	CrossFieldManagerI,
+	getChangeHandler,
+	getRevInfoFromTaggedChanges,
+	hasConflicts,
+	makeModularChangeset,
+	newConstraintState,
+	newCrossFieldTable,
+	updateConstraintsForFields,
+	type CrossFieldTable,
+} from "./modularChangeUtils.js";
+import type { CrossFieldTarget } from "./crossFieldQueries.js";
+import type { FlexFieldKind } from "./fieldKind.js";
+import { NodeAttachState } from "./fieldChangeHandler.js";
+
+/**
+ * @param change - The change to invert.
+ * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
+ * performing a sandwich rebase.
+ * @param revisionForInvert - The revision for the invert changeset.
+ */
+export function invertModularChange(
+	change: TaggedChange<ModularChangeset>,
+	isRollback: boolean,
+	revisionForInvert: RevisionTag,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	// Rollback changesets destroy the nodes created by the change being rolled back.
+	const destroys = isRollback ? invertBuilds(change.change.builds) : undefined;
+
+	// Destroys only occur in rollback changesets, which are never inverted.
+	assert(
+		change.change.destroys === undefined,
+		0x89a /* Unexpected destroys in change to invert */,
+	);
+
+	const revInfos: RevisionInfo[] = isRollback
+		? [{ revision: revisionForInvert, rollbackOf: change.revision }]
+		: [{ revision: revisionForInvert }];
+
+	const noChangeConstraint = change.change.noChangeConstraintOnRevert;
+	const noChangeConstraintOnRevert = change.change.noChangeConstraint;
+
+	if (hasConflicts(change.change)) {
+		return makeModularChangeset({
+			maxId: change.change.maxId as number,
+			revisions: revInfos,
+			destroys,
+		});
+	}
+
+	const genId: IdAllocator = idAllocatorFromMaxId(change.change.maxId ?? -1);
+
+	const crossFieldTable: InvertTable = {
+		...newCrossFieldTable<FieldChange>(),
+		originalFieldToContext: new Map(),
+		invertedNodeToParent: brand(change.change.nodeToParent.clone()),
+	};
+	const { revInfos: oldRevInfos } = getRevInfoFromTaggedChanges([change]);
+	const revisionMetadata = revisionMetadataSourceFromInfo(oldRevInfos);
+
+	const invertedFields = invertFieldMap(
+		change.change.fieldChanges,
+		undefined,
+		isRollback,
+		genId,
+		crossFieldTable,
+		revisionMetadata,
+		revisionForInvert,
+		fieldKinds,
+	);
+
+	const invertedNodes = newChangeAtomIdBTree<NodeChangeset>();
+	change.change.nodeChanges.forEachPair(([revision, localId], nodeChangeset) => {
+		invertedNodes.set(
+			[revision, localId],
+			invertNodeChange(
+				nodeChangeset,
+				{ revision, localId },
+				isRollback,
+				genId,
+				crossFieldTable,
+				revisionMetadata,
+				revisionForInvert,
+				fieldKinds,
+			),
+		);
+	});
+
+	if (crossFieldTable.invalidatedFields.size > 0) {
+		const fieldsToUpdate = crossFieldTable.invalidatedFields;
+		crossFieldTable.invalidatedFields = new Set();
+		for (const fieldChange of fieldsToUpdate) {
+			const originalFieldChange = fieldChange.change;
+			const context = crossFieldTable.originalFieldToContext.get(fieldChange);
+			assert(
+				context !== undefined,
+				0x851 /* Should have context for every invalidated field */,
+			);
+			const { invertedField, fieldId } = context;
+
+			const amendedChange = getChangeHandler(fieldKinds, fieldChange.fieldKind).rebaser.invert(
+				originalFieldChange,
+				isRollback,
+				genId,
+				revisionForInvert,
+				new InvertManager(crossFieldTable, fieldChange, fieldId),
+				revisionMetadata,
+			);
+			invertedField.change = brand(amendedChange);
+		}
+	}
+
+	const crossFieldKeys = makeCrossFieldKeyTable(invertedFields, invertedNodes, fieldKinds);
+
+	const constraintState = newConstraintState(0);
+	updateConstraintsForFields(
+		invertedFields,
+		NodeAttachState.Attached,
+		constraintState,
+		invertedNodes,
+		fieldKinds,
+	);
+
+	return makeModularChangeset({
+		fieldChanges: invertedFields,
+		nodeChanges: invertedNodes,
+		nodeToParent: crossFieldTable.invertedNodeToParent,
+		nodeAliases: change.change.nodeAliases,
+		crossFieldKeys,
+		maxId: genId.getMaxId(),
+		revisions: revInfos,
+		constraintViolationCount: constraintState.violationCount,
+		noChangeConstraint,
+		noChangeConstraintOnRevert,
+		destroys,
+	});
+}
+
+function invertFieldMap(
+	changes: FieldChangeMap,
+	parentId: NodeId | undefined,
+	isRollback: boolean,
+	genId: IdAllocator,
+	crossFieldTable: InvertTable,
+	revisionMetadata: RevisionMetadataSource,
+	revisionForInvert: RevisionTag,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): FieldChangeMap {
+	const invertedFields: FieldChangeMap = new Map();
+
+	for (const [field, fieldChange] of changes) {
+		const fieldId = { nodeId: parentId, field };
+		const manager = new InvertManager(crossFieldTable, fieldChange, fieldId);
+		const invertedChange = getChangeHandler(fieldKinds, fieldChange.fieldKind).rebaser.invert(
+			fieldChange.change,
+			isRollback,
+			genId,
+			revisionForInvert,
+			manager,
+			revisionMetadata,
+		);
+
+		const invertedFieldChange: FieldChange = {
+			...fieldChange,
+			change: brand(invertedChange),
+		};
+		invertedFields.set(field, invertedFieldChange);
+
+		crossFieldTable.originalFieldToContext.set(fieldChange, {
+			fieldId,
+			invertedField: invertedFieldChange,
+		});
+	}
+
+	return invertedFields;
+}
+
+function invertNodeChange(
+	change: NodeChangeset,
+	id: NodeId,
+	isRollback: boolean,
+	genId: IdAllocator,
+	crossFieldTable: InvertTable,
+	revisionMetadata: RevisionMetadataSource,
+	revisionForInvert: RevisionTag,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): NodeChangeset {
+	const inverse: NodeChangeset = {};
+
+	// If the node has a constraint, it should be inverted to a node-exist-on-revert constraint. This ensure that if
+	// the inverse is inverted again, the original input constraint will be restored.
+	if (change.nodeExistsConstraint !== undefined) {
+		inverse.nodeExistsConstraintOnRevert = change.nodeExistsConstraint;
+	}
+
+	// The node-exist-on-revert constraint of a node is the constraint that should apply when the a change is reverted.
+	// So, it should become the constraint in the inverse. If this constraint is violated when applying the inverse,
+	// it will be discarded.
+	if (change.nodeExistsConstraintOnRevert !== undefined) {
+		inverse.nodeExistsConstraint = change.nodeExistsConstraintOnRevert;
+	}
+
+	if (change.fieldChanges !== undefined) {
+		inverse.fieldChanges = invertFieldMap(
+			change.fieldChanges,
+			id,
+			isRollback,
+			genId,
+			crossFieldTable,
+			revisionMetadata,
+			revisionForInvert,
+			fieldKinds,
+		);
+	}
+
+	return inverse;
+}
+
+function invertBuilds(
+	builds: ChangeAtomIdBTree<TreeChunk> | undefined,
+): ChangeAtomIdBTree<number> | undefined {
+	if (builds !== undefined) {
+		return brand(builds.mapValues((chunk) => chunk.topLevelLength));
+	}
+	return undefined;
+}
+
+interface InvertTable extends CrossFieldTable<FieldChange> {
+	originalFieldToContext: Map<FieldChange, InvertContext>;
+	invertedNodeToParent: ChangeAtomIdBTree<FieldId>;
+}
+
+interface InvertContext {
+	fieldId: FieldId;
+	invertedField: FieldChange;
+}
+
+class InvertManager extends CrossFieldManagerI<FieldChange> {
+	public constructor(
+		table: InvertTable,
+		field: FieldChange,
+		private readonly fieldId: FieldId,
+		allowInval = true,
+	) {
+		super(table, field, allowInval);
+	}
+
+	public override onMoveIn(id: ChangeAtomId): void {
+		setInChangeAtomIdMap(this.table.invertedNodeToParent, id, this.fieldId);
+	}
+
+	public override moveKey(
+		target: CrossFieldTarget,
+		revision: RevisionTag | undefined,
+		id: ChangesetLocalId,
+		count: number,
+	): void {
+		assert(false, 0x9c5 /* Keys should not be moved manually during invert */);
+	}
+
+	private get table(): InvertTable {
+		return this.crossFieldTable as InvertTable;
+	}
+}
+
+function makeCrossFieldKeyTable(
+	fields: FieldChangeMap,
+	nodes: ChangeAtomIdBTree<NodeChangeset>,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): CrossFieldKeyTable {
+	const keys: CrossFieldKeyTable = newCrossFieldKeyTable();
+	populateCrossFieldKeyTableForFieldMap(keys, fields, undefined, fieldKinds);
+	nodes.forEachPair(([revision, localId], node) => {
+		if (node.fieldChanges !== undefined) {
+			populateCrossFieldKeyTableForFieldMap(
+				keys,
+				node.fieldChanges,
+				{
+					revision,
+					localId,
+				},
+				fieldKinds,
+			);
+		}
+	});
+
+	return keys;
+}
+
+function populateCrossFieldKeyTableForFieldMap(
+	table: CrossFieldKeyTable,
+	fields: FieldChangeMap,
+	parent: NodeId | undefined,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): void {
+	for (const [fieldKey, fieldChange] of fields) {
+		const keys = getChangeHandler(fieldKinds, fieldChange.fieldKind).getCrossFieldKeys(
+			fieldChange.change,
+		);
+		for (const { key, count } of keys) {
+			table.set(key, count, { nodeId: parent, field: fieldKey });
+		}
+	}
+}

package/src/feature-libraries/modular-schema/minimizeModularChange.ts

@@ -3,9 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { FieldKindIdentifier } from "../../core/index.js";
-
-import type { FlexFieldKind } from "./fieldKind.js";
+import type { ModularChangeFamily } from "./modularChangeFamily.js";
 import type { ModularChangeset } from "./modularChangeTypes.js";
 
 /**
@@ -22,11 +20,11 @@ import type { ModularChangeset } from "./modularChangeTypes.js";
  * future change.
  *
  * @param change - The change to minimize.
- * @param fieldKinds - The field kinds to delegate to when computing the change's delta.
+ * @param changeFamily - The change family used to compute the change's delta and identify built nodes.
  */
 export function minimizeModularChangeset(
 	change: ModularChangeset,
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+	changeFamily: ModularChangeFamily,
 ): ModularChangeset {
 	// TODO: Actually minimize the change. For now this is a no-op that returns the change unchanged.
 	return change;

package/src/feature-libraries/modular-schema/modularChangeCodecV1.ts

@@ -16,6 +16,7 @@ import {
 } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
+	ChangeDecodingContext,
 	ChangesetLocalId,
 	EncodedRevisionTag,
 	FieldKey,
@@ -42,7 +43,11 @@ import {
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
 
-import type { FieldChangeEncodingContext, FieldChangeHandler } from "./fieldChangeHandler.js";
+import type {
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext,
+	FieldChangeHandler,
+} from "./fieldChangeHandler.js";
 import type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
@@ -71,14 +76,16 @@ type ModularChangeCodec = IJsonCodec<
 	ModularChangeset,
 	EncodedModularChangesetV1,
 	EncodedModularChangesetV1,
-	ChangeEncodingContext
+	ChangeEncodingContext,
+	ChangeDecodingContext
 >;
 
 type FieldCodec = IJsonCodec<
 	FieldChangeset,
 	JsonCompatibleReadOnly,
 	JsonCompatibleReadOnly,
-	FieldChangeEncodingContext
+	FieldChangeEncodingContext,
+	FieldChangeDecodingContext
 >;
 
 type FieldChangesetCodecs = Map<
@@ -115,8 +122,6 @@ export function encodeFieldChangesForJson(
 			assert(node !== undefined, 0x92e /* Unknown node ID */);
 			return encodeNodeChangesForJson(node, fieldContext, fieldChangesetCodecs);
 		},
-
-		decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
 	};
 
 	return encodeFieldChangesForJsonI(change, fieldContext, fieldChangesetCodecs);
@@ -180,7 +185,7 @@ export function decodeFieldChangesFromJson(
 	encodedChange: EncodedFieldChangeMap,
 	parentId: NodeId | undefined,
 	decoded: ModularChangeset,
-	context: ChangeEncodingContext,
+	context: ChangeDecodingContext,
 	idAllocator: IdAllocator,
 	fieldKinds: FieldKindConfiguration,
 	fieldChangesetCodecs: FieldChangesetCodecs,
@@ -200,11 +205,9 @@ export function decodeFieldChangesFromJson(
 			field: field.fieldKey,
 		};
 
-		const fieldContext: FieldChangeEncodingContext = {
+		const fieldContext: FieldChangeDecodingContext = {
 			baseContext: context,
 
-			encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
-
 			decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
 				const nodeId: NodeId = {
 					revision: context.revision,
@@ -252,7 +255,7 @@ export function decodeNodeChangesetFromJson(
 	encodedChange: EncodedNodeChangeset,
 	id: NodeId,
 	decoded: ModularChangeset,
-	context: ChangeEncodingContext,
+	context: ChangeDecodingContext,
 	idAllocator: IdAllocator,
 	fieldKinds: FieldKindConfiguration,
 	fieldChangesetCodecs: FieldChangesetCodecs,
@@ -337,7 +340,7 @@ export function encodeDetachedNodes(
 
 export function decodeDetachedNodes(
 	encoded: EncodedBuilds | undefined,
-	context: ChangeEncodingContext,
+	context: ChangeDecodingContext,
 	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
 		typeof RevisionTagSchema,
@@ -430,7 +433,7 @@ export function encodeRevisionInfos(
 
 export function decodeRevisionInfos(
 	revisions: readonly EncodedRevisionInfo[] | undefined,
-	context: ChangeEncodingContext,
+	context: ChangeDecodingContext,
 	revisionTagCodec: JsonCodecPart<
 		RevisionTag,
 		typeof RevisionTagSchema,
@@ -509,7 +512,7 @@ export function encodeChange(
 
 export function decodeChange(
 	encodedChange: EncodedModularChangesetV1,
-	context: ChangeEncodingContext,
+	context: ChangeDecodingContext,
 	fieldKinds: FieldKindConfiguration,
 	fieldChangesetCodecs: Map<
 		FieldKindIdentifier,

package/src/feature-libraries/modular-schema/modularChangeCodecV2.ts

@@ -11,6 +11,7 @@ import {
 } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
+	ChangeDecodingContext,
 	RevisionTag,
 	RevisionTagSchema,
 } from "../../core/index.js";
@@ -30,7 +31,8 @@ type ModularChangeCodec = IJsonCodec<
 	ModularChangeset,
 	EncodedModularChangesetV2,
 	EncodedModularChangesetV2,
-	ChangeEncodingContext
+	ChangeEncodingContext,
+	ChangeDecodingContext
 >;
 
 export function makeModularChangeCodecV2(

package/src/feature-libraries/modular-schema/modularChangeCodecs.ts

@@ -13,6 +13,7 @@ import {
 } from "../../codec/index.js";
 import type {
 	ChangeEncodingContext,
+	ChangeDecodingContext,
 	RevisionTag,
 	RevisionTagSchema,
 } from "../../core/index.js";
@@ -35,7 +36,7 @@ export function makeModularChangeCodecFamily(
 	fieldsCodec: FieldBatchCodec,
 	codecOptions: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
-): ICodecFamily<ModularChangeset, ChangeEncodingContext> {
+): ICodecFamily<ModularChangeset, ChangeEncodingContext, ChangeDecodingContext> {
 	return makeCodecFamily(
 		Array.from(fieldKindConfigurations.entries(), ([version, fieldKinds]) => {
 			switch (version) {