@fluidframework/tree 2.43.0 → 2.50.0

package/src/core/schema-stored/schema.ts

@@ -185,8 +185,6 @@ export const storedEmptyFieldSchema: TreeFieldStoredSchema = {
  */
 export const identifierFieldKindIdentifier = "Identifier";
 
-/**
- */
 export abstract class TreeNodeStoredSchema {
 	protected _typeCheck!: MakeNominal;
 
@@ -213,8 +211,6 @@ export abstract class TreeNodeStoredSchema {
 	public abstract getFieldSchema(field: FieldKey): TreeFieldStoredSchema;
 }
 
-/**
- */
 export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 	/**
 	 * @param objectNodeFields -
@@ -272,8 +268,6 @@ export class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
 	}
 }
 
-/**
- */
 export class MapNodeStoredSchema extends TreeNodeStoredSchema {
 	/**
 	 * @param mapFields -
@@ -306,8 +300,6 @@ export class MapNodeStoredSchema extends TreeNodeStoredSchema {
 	}
 }
 
-/**
- */
 export class LeafNodeStoredSchema extends TreeNodeStoredSchema {
 	/**
 	 * @param leafValue -

package/src/core/schema-view/view.ts

@@ -9,8 +9,6 @@ import type { TreeNodeSchemaIdentifier, TreeStoredSchema } from "../schema-store
  * APIs for applying `view schema` to documents.
  */
 
-/**
- */
 export interface TreeAdapter {
 	readonly output: TreeNodeSchemaIdentifier;
 	readonly input: TreeNodeSchemaIdentifier;

package/src/core/tree/cursor.ts

@@ -312,8 +312,6 @@ export interface PathRootPrefix {
 	indexOffset?: number;
 }
 
-/**
- */
 export const enum CursorLocationType {
 	/**
 	 * Can iterate through nodes in a field.

package/src/core/tree/delta.ts

@@ -158,8 +158,6 @@ export interface DetachedNodeId {
 	readonly minor: number;
 }
 
-/**
- */
 export type FieldMap = ReadonlyMap<FieldKey, FieldChanges>;
 
 /**

package/src/core/tree/types.ts

@@ -18,8 +18,6 @@ import type {
 	ValueSchema,
 } from "../schema-stored/index.js";
 
-/**
- */
 export type TreeType = TreeNodeSchemaIdentifier;
 
 /**
@@ -43,8 +41,6 @@ export const EmptyKey: FieldKey = brand("");
  */
 export const rootFieldKey: FieldKey = brand("rootFieldKey");
 
-/**
- */
 export const rootField = keyAsDetachedField(rootFieldKey);
 
 /**

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -410,8 +410,6 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 	}
 }
 
-/**
- */
 export interface ValueFieldEditBuilder<TContent> {
 	/**
 	 * Issues a change which replaces the current newContent of the field with `newContent`.
@@ -421,8 +419,6 @@ export interface ValueFieldEditBuilder<TContent> {
 	set(newContent: TContent): void;
 }
 
-/**
- */
 export interface OptionalFieldEditBuilder<TContent> {
 	/**
 	 * Issues a change which replaces the current newContent of the field with `newContent`

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -257,20 +257,10 @@ export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor> =
 // TODO: Find a way to make docs like {@inheritDoc required} work in vscode.
 // TODO: ensure thy work in generated docs.
 // TODO: add these comments to the rest of the cases below.
-/**
- */
 export interface Required extends FlexFieldKind<"Value", Multiplicity.Single> {}
-/**
- */
 export interface Optional extends FlexFieldKind<"Optional", Multiplicity.Optional> {}
-/**
- */
 export interface Sequence extends FlexFieldKind<"Sequence", Multiplicity.Sequence> {}
-/**
- */
 export interface Identifier extends FlexFieldKind<"Identifier", Multiplicity.Single> {}
-/**
- */
 export interface Forbidden
 	extends FlexFieldKind<typeof forbiddenFieldKindIdentifier, Multiplicity.Forbidden> {}
 

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -47,8 +47,6 @@ export function isFlexTreeNode(t: unknown): t is FlexTreeNode {
 	return isFlexTreeEntity(t) && t[flexTreeMarker] === FlexTreeEntityKind.Node;
 }
 
-/**
- */
 export enum FlexTreeEntityKind {
 	Node,
 	Field,

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

@@ -44,8 +44,6 @@ export function getFirstFromCrossFieldMap<T>(
 	return map.getFirst({ revision, localId: id }, count);
 }
 
-/**
- */
 export enum CrossFieldTarget {
 	Source,
 	Destination,

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

@@ -216,19 +216,13 @@ export interface FieldEditor<TChangeset> {
  */
 export type ToDelta = (child: NodeId) => DeltaFieldMap;
 
-/**
- */
 export type NodeChangeInverter = (change: NodeId) => NodeId;
 
-/**
- */
 export enum NodeAttachState {
 	Attached,
 	Detached,
 }
 
-/**
- */
 export type NodeChangeRebaser = (
 	change: NodeId | undefined,
 	baseChange: NodeId | undefined,
@@ -239,15 +233,11 @@ export type NodeChangeRebaser = (
 	state?: NodeAttachState,
 ) => NodeId | undefined;
 
-/**
- */
 export type NodeChangeComposer = (
 	change1: NodeId | undefined,
 	change2: NodeId | undefined,
 ) => NodeId;
 
-/**
- */
 export type NodeChangePruner = (change: NodeId) => NodeId | undefined;
 
 /**

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

@@ -2285,8 +2285,6 @@ function newCrossFieldTable<T>(): CrossFieldTable<T> {
 	};
 }
 
-/**
- */
 interface ConstraintState {
 	violationCount: number;
 }
@@ -2913,8 +2911,6 @@ function buildModularChangesetFromNode(props: {
 	});
 }
 
-/**
- */
 export interface FieldEditDescription {
 	type: "field";
 	field: FieldUpPath;
@@ -2923,16 +2919,12 @@ export interface FieldEditDescription {
 	revision: RevisionTag;
 }
 
-/**
- */
 export interface GlobalEditDescription {
 	type: "global";
 	revision: RevisionTag;
 	builds?: ChangeAtomIdBTree<TreeChunk>;
 }
 
-/**
- */
 export type EditDescription = FieldEditDescription | GlobalEditDescription;
 
 function getRevInfoFromTaggedChanges(changes: TaggedChange<ModularChangeset>[]): {

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

@@ -17,8 +17,6 @@ import type { TreeChunk } from "../chunked-forest/index.js";
 
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
-/**
- */
 export interface ModularChangeset extends HasFieldChanges {
 	/**
 	 * The numerically highest `ChangesetLocalId` used in this changeset.
@@ -110,8 +108,6 @@ export interface FieldId {
 	readonly field: FieldKey;
 }
 
-/**
- */
 export interface NodeExistsConstraint {
 	violated: boolean;
 }
@@ -128,23 +124,15 @@ export interface NodeChangeset extends HasFieldChanges {
 
 export type NodeId = ChangeAtomId;
 
-/**
- */
 export interface HasFieldChanges {
 	fieldChanges?: FieldChangeMap;
 }
 
-/**
- */
 export type FieldChangeMap = Map<FieldKey, FieldChange>;
 
-/**
- */
 export interface FieldChange {
 	fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 }
 
-/**
- */
 export type FieldChangeset = Brand<unknown, "FieldChangeset">;

package/src/feature-libraries/sequence-field/types.ts

@@ -24,8 +24,6 @@ export interface HasMoveId {
 	id: MoveId;
 }
 
-/**
- */
 export interface CellId extends ChangeAtomId {}
 
 /**

package/src/index.ts

@@ -130,6 +130,7 @@ export {
 	type FieldSchemaAlphaUnsafe,
 	type ArrayNodeCustomizableSchemaUnsafe,
 	type MapNodeCustomizableSchemaUnsafe,
+	type TreeRecordNodeUnsafe,
 	// System types (not in Internal types for various reasons, like doc links or cannot be named errors).
 	type typeSchemaSymbol,
 	type TreeNodeSchemaNonClass,
@@ -196,6 +197,8 @@ export {
 	type JsonRefPath,
 	type JsonSchemaType,
 	type JsonLeafSchemaType,
+	type JsonRecordNodeSchema,
+	type JsonStringKeyPatternProperties,
 	getJsonSchema,
 	type LazyItem,
 	type Unenforced,
@@ -209,6 +212,7 @@ export {
 	type SimpleArrayNodeSchema,
 	type SimpleObjectNodeSchema,
 	type SimpleObjectFieldSchema,
+	type SimpleRecordNodeSchema,
 	normalizeAllowedTypes,
 	getSimpleSchema,
 	type ReadonlyArrayNode,
@@ -249,6 +253,11 @@ export {
 	type ObjectFromSchemaRecord,
 	type ValidateRecursiveSchemaTemplate,
 	type FixRecursiveRecursionLimit,
+	RecordNodeSchema,
+	type RecordNodeCustomizableSchema,
+	type RecordNodeInsertableData,
+	type RecordNodePojoEmulationSchema,
+	type TreeRecordNode,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/jsonDomainSchema.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { SchemaFactory } from "./simple-tree/index.js";
+import { SchemaFactory, SchemaFactoryAlpha } from "./simple-tree/index.js";
 import type {
 	AllowedTypes,
 	FixRecursiveArraySchema,
@@ -22,7 +22,7 @@ import type {
 	// #endregion
 } from "./simple-tree/index.js";
 
-const sf = new SchemaFactory("com.fluidframework.json");
+const sf = new SchemaFactoryAlpha("com.fluidframework.json");
 
 /**
  * Utilities for storing JSON data in {@link TreeNode}s.
@@ -80,7 +80,7 @@ export namespace JsonAsTree {
 	 * Do not use. Exists only as a workaround for {@link https://github.com/microsoft/TypeScript/issues/59550} and {@link https://github.com/microsoft/rushstack/issues/4429}.
 	 * @system @alpha
 	 */
-	export const _APIExtractorWorkaroundObjectBase = sf.mapRecursive("object", Tree);
+	export const _APIExtractorWorkaroundObjectBase = sf.recordRecursive("object", Tree);
 
 	/**
 	 * Arbitrary JSON object as a {@link TreeNode}.

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.43.0";
+export const pkgVersion = "2.50.0";

package/src/shared-tree/treeAlpha.ts

@@ -592,6 +592,7 @@ export const TreeAlpha: TreeAlpha = {
 					return undefined;
 				}
 			// Fall through
+			case NodeKind.Record:
 			case NodeKind.Object: {
 				let storedKey: string | number = propertyKey;
 				if (isObjectNodeSchema(schema)) {
@@ -643,7 +644,8 @@ export const TreeAlpha: TreeAlpha = {
 				}
 				break;
 			}
-			case NodeKind.Map: {
+			case NodeKind.Map:
+			case NodeKind.Record: {
 				for (const [key, flexField] of flexNode.fields) {
 					const childTreeNode = tryGetTreeNodeForField(flexField);
 					if (childTreeNode !== undefined) {

package/src/shared-tree-core/defaultResubmitMachine.ts

@@ -3,13 +3,25 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob } from "@fluidframework/core-utils/internal";
+import {
+	assert,
+	DoublyLinkedList,
+	oob,
+	type ListNode,
+	type ListNodeRange,
+} from "@fluidframework/core-utils/internal";
 
 import type { GraphCommit, TaggedChange } from "../core/index.js";
 import { disposeSymbol, hasSome } from "../util/index.js";
 
 import type { ChangeEnricherReadonlyCheckout, ResubmitMachine } from "./index.js";
 
+interface PendingChange<TChange> {
+	commit: GraphCommit<TChange>;
+	lastEnrichment: number;
+}
+type PendingChangeNode<TChange> = ListNode<PendingChange<TChange>>;
+
 /**
  * Default implementation of {@link ResubmitMachine}.
  */
@@ -17,24 +29,20 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 	/**
 	 * The list of commits (from oldest to most recent) that have been submitted but not sequenced.
 	 */
-	private inFlightQueue: GraphCommit<TChange>[] = [];
+	private readonly inFlightQueue: DoublyLinkedList<PendingChange<TChange>> =
+		new DoublyLinkedList();
 
 	/**
-	 * The list of commits (from oldest to most recent) that should be resubmitted.
+	 * The range of in-flight commits that are currently being resubmitted.
+	 * Defined only during the resubmit phase.
 	 */
-	private resubmitQueue: GraphCommit<TChange>[] = [];
+	private pendingResubmitRange: ListNodeRange<PendingChange<TChange>> | undefined;
 
 	/**
-	 * Represents the index in the `inFlightQueue` array of the most recent in flight commit that has
-	 * undergone rebasing but whose enrichments have not been updated.
-	 * All in-flight commits with an index inferior or equal to this number have stale enrichments.
-	 *
-	 * Is -1 when *any* of the following is true:
-	 * - There are no in-flight commits (i.e., no local commits have been made or they have all been sequenced)
-	 * - None of the in-flight commits have been rebased
-	 * - In-flight commits that have been rebased have all had their enrichments updated
+	 * The current enrichment version for in-flight commits.
+	 * Incremented when a peer commit is sequenced.
 	 */
-	private latestInFlightCommitWithStaleEnrichments: number = -1;
+	private currentEnrichment: number = 0;
 
 	public constructor(
 		/**
@@ -49,14 +57,31 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 	) {}
 
 	public onCommitSubmitted(commit: GraphCommit<TChange>): void {
-		if (this.isInResubmitPhase) {
-			const toResubmit = this.resubmitQueue.shift();
+		if (this.pendingResubmitRange !== undefined) {
+			const toResubmit = this.pendingResubmitRange?.first;
 			assert(
-				toResubmit === commit,
+				toResubmit?.data.commit === commit,
 				0x981 /* Unexpected commit submitted during resubmit phase */,
 			);
+			// If we are not at the last commit to resubmit, advance the range to the next node.
+			// Otherwise, clear the resubmit range as we are done resubmitting.
+			if (toResubmit !== this.pendingResubmitRange.last) {
+				assert(toResubmit.next !== undefined, 0xbd6 /* must be more in the list */);
+				this.pendingResubmitRange.first = toResubmit.next;
+			} else {
+				this.pendingResubmitRange = undefined;
+			}
+			toResubmit.remove();
 		}
-		this.inFlightQueue.push(commit);
+		this.inFlightQueue.push({ commit, lastEnrichment: this.currentEnrichment });
+	}
+
+	public onCommitRollback(commit: GraphCommit<TChange>): void {
+		assert(
+			commit.revision === this.inFlightQueue.last?.data.commit.revision,
+			0xbd7 /* must rollback latest commit in the in flight queue */,
+		);
+		this.inFlightQueue.pop();
 	}
 
 	public prepareForResubmit(toResubmit: readonly GraphCommit<TChange>[]): void {
@@ -64,16 +89,33 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			!this.isInResubmitPhase,
 			0x957 /* Invalid resubmit phase start during incomplete resubmit phase */,
 		);
+
+		if (!hasSome(toResubmit)) {
+			return;
+		}
+
 		assert(
-			toResubmit.length === this.inFlightQueue.length,
-			0x958 /* Unexpected resubmit of more or fewer commits than are in flight */,
+			toResubmit.length <= this.inFlightQueue.length,
+			0xbd8 /* Unexpected resubmit of more commits than are in flight */,
 		);
-		if (this.latestInFlightCommitWithStaleEnrichments === -1) {
-			// No in-flight commits have stale enrichments, so we can resubmit them as is
-			this.resubmitQueue = this.inFlightQueue;
-			this.inFlightQueue = [];
-		} else {
+
+		// Find the first in-flight commit to resubmit.
+		const first = this.inFlightQueue.find(
+			(v) => v.data.commit.revision === toResubmit[0].revision,
+		);
+		// Always resubmit to the end of all outstanding ops, but the list may grow during resubmit,
+		// so we must track the current end at the start of the phase.
+		const last = this.inFlightQueue.last;
+		assert(
+			first !== undefined && last !== undefined,
+			0xbd9 /* there must be inflight commits to resubmit */,
+		);
+
+		this.pendingResubmitRange = { first, last };
+		// If any in-flight commits have stale enrichments, recompute them.
+		if (first.data.lastEnrichment < this.currentEnrichment) {
 			const checkout = this.tip.fork();
+
 			// Roll back the checkout to the state before the oldest commit
 			for (let iCommit = toResubmit.length - 1; iCommit >= 0; iCommit -= 1) {
 				const commit = toResubmit[iCommit] ?? oob();
@@ -83,32 +125,37 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 				// forwards from an earlier fork instead of backwards.
 				checkout.applyTipChange(rollback);
 			}
-			// Update the enrichments of the stale commits
-			for (
-				let iCommit = 0;
-				iCommit <= this.latestInFlightCommitWithStaleEnrichments;
-				iCommit += 1
-			) {
-				const commit = toResubmit[iCommit] ?? oob();
-				const enrichedChange = checkout.updateChangeEnrichments(
-					commit.change,
-					commit.revision,
+
+			// Update the enrichments of the stale commits in the in-flight queue.
+			let current: PendingChangeNode<TChange> | undefined = first;
+			for (const commit of toResubmit) {
+				assert(
+					current !== undefined,
+					0xbda /* there must be an inflight commit for each resubmit commit */,
 				);
-				const enrichedCommit = { ...commit, change: enrichedChange };
-				this.resubmitQueue.push(enrichedCommit);
-				if (iCommit < this.latestInFlightCommitWithStaleEnrichments) {
-					checkout.applyTipChange(enrichedChange, commit.revision);
+				current.data.commit = commit;
+				if (current.data.lastEnrichment < this.currentEnrichment) {
+					const enrichedChange = checkout.updateChangeEnrichments(
+						commit.change,
+						commit.revision,
+					);
+					const enrichedCommit = { ...commit, change: enrichedChange };
+
+					// Optimization: only apply the enriched change if the next commit also needs enrichment.
+					if (
+						current.next !== undefined &&
+						current.next.data.lastEnrichment < this.currentEnrichment
+					) {
+						checkout.applyTipChange(enrichedChange, commit.revision);
+					}
+
+					current.data.commit = enrichedCommit;
+					current.data.lastEnrichment = this.currentEnrichment;
 				}
-				this.inFlightQueue.shift();
+				current = current.next;
 			}
 			checkout[disposeSymbol]();
-			// Whatever commits are left do not have stale enrichments
-			for (const commit of this.inFlightQueue) {
-				this.resubmitQueue.push(commit);
-			}
-			this.inFlightQueue.length = 0;
 		}
-		this.latestInFlightCommitWithStaleEnrichments = -1;
 	}
 
 	public peekNextCommit(): GraphCommit<TChange> {
@@ -116,12 +163,15 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			this.isInResubmitPhase,
 			0x982 /* No available commit to resubmit outside of resubmit phase */,
 		);
-		assert(hasSome(this.resubmitQueue), 0xa87 /* Expected resubmit queue to be non-empty */);
-		return this.resubmitQueue[0];
+		assert(
+			this.pendingResubmitRange !== undefined,
+			0xa87 /* Expected resubmit queue to be non-empty */,
+		);
+		return this.pendingResubmitRange.first.data.commit;
 	}
 
 	public get isInResubmitPhase(): boolean {
-		return this.resubmitQueue.length !== 0;
+		return this.pendingResubmitRange !== undefined;
 	}
 
 	public onSequencedCommitApplied(isLocal: boolean): void {
@@ -129,12 +179,9 @@ export class DefaultResubmitMachine<TChange> implements ResubmitMachine<TChange>
 			// The oldest in-flight commit has been sequenced
 			assert(this.inFlightQueue.length > 0, 0x959 /* Sequencing of unknown local commit */);
 			this.inFlightQueue.shift();
-			if (this.latestInFlightCommitWithStaleEnrichments >= 0) {
-				this.latestInFlightCommitWithStaleEnrichments -= 1;
-			}
 		} else {
 			// A peer commit has been sequenced
-			this.latestInFlightCommitWithStaleEnrichments = this.inFlightQueue.length - 1;
+			this.currentEnrichment++;
 		}
 	}
 }

package/src/shared-tree-core/resubmitMachine.ts

@@ -37,6 +37,13 @@ export interface ResubmitMachine<TChange> {
 	 */
 	onCommitSubmitted(commit: GraphCommit<TChange>): void;
 
+	/**
+	 * Must be called on a commit after rollback, so it can be removed
+	 * as it will never be (re)submitted.
+	 * @param commit - The commit that was rolled back
+	 */
+	onCommitRollback(commit: GraphCommit<TChange>): void;
+
 	/**
 	 * Must be called after a sequenced commit is applied.
 	 * Note that this may be called multiples times in a row after a number of sequenced commits have been applied

package/src/shared-tree-core/sharedTreeCore.ts

@@ -397,14 +397,12 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		} = this.messageCodec.decode(this.serializer.decode(content), {
 			idCompressor: this.idCompressor,
 		});
-		const [commit] = this.editManager.findLocalCommit(revision);
 		// If a resubmit phase is not already in progress, then this must be the first commit of a new resubmit phase.
 		if (this.resubmitMachine.isInResubmitPhase === false) {
-			const toResubmit = this.editManager.getLocalCommits();
-			assert(
-				commit === toResubmit[0],
-				0x95d /* Resubmit phase should start with the oldest local commit */,
-			);
+			const localCommits = this.editManager.getLocalCommits();
+			const revisionIndex = localCommits.findIndex((c) => c.revision === revision);
+			assert(revisionIndex >= 0, 0xbdb /* revision must exist in local commits */);
+			const toResubmit = localCommits.slice(revisionIndex);
 			this.resubmitMachine.prepareForResubmit(toResubmit);
 		}
 		assert(
@@ -418,6 +416,20 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		const enrichedCommit = this.resubmitMachine.peekNextCommit();
 		this.submitCommit(enrichedCommit, localOpMetadata, true);
 	}
+	public rollback(content: JsonCompatibleReadOnly, localOpMetadata: unknown): void {
+		// Empty context object is passed in, as our decode function is schema-agnostic.
+		const {
+			commit: { revision },
+		} = this.messageCodec.decode(this.serializer.decode(content), {
+			idCompressor: this.idCompressor,
+		});
+		const [commit] = this.editManager.findLocalCommit(revision);
+		const { parent } = commit;
+		assert(parent !== undefined, 0xbdc /* must have parent */);
+		const [precedingCommit] = this.editManager.findLocalCommit(parent.revision);
+		this.editManager.localBranch.removeAfter(precedingCommit);
+		this.resubmitMachine.onCommitRollback(commit);
+	}
 
 	public applyStashedOp(content: JsonCompatibleReadOnly): void {
 		// Empty context object is passed in, as our decode function is schema-agnostic.