@fluidframework/tree 2.63.0-359734 → 2.63.0

package/src/simple-tree/prepareForInsertion.ts

@@ -7,7 +7,6 @@ import type {
 	SchemaAndPolicy,
 	IForestSubscription,
 	UpPath,
-	NodeIndex,
 	FieldKey,
 	DetachedField,
 	TreeFieldStoredSchema,
@@ -21,6 +20,10 @@ import {
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	throwOutOfSchema,
+	flexTreeSlot,
+	ContextSlot,
+	getOrCreateHydratedFlexTreeNode,
+	assertFlexTreeEntityNotFreed,
 } from "../feature-libraries/index.js";
 import type { ImplicitFieldSchema } from "./fieldSchema.js";
 import {
@@ -28,14 +31,14 @@ import {
 	unhydratedFlexTreeFromInsertable,
 } from "./unhydratedFlexTreeFromInsertable.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { brand } from "../util/index.js";
+import { brand, type Mutable } from "../util/index.js";
 import {
 	getKernel,
 	type ImplicitAllowedTypes,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { debugAssert, oob } from "@fluidframework/core-utils/internal";
+import { debugAssert, fail, oob } from "@fluidframework/core-utils/internal";
 import { isFieldInSchema } from "../feature-libraries/index.js";
 
 /**
@@ -121,11 +124,18 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	destinationSchema: TreeFieldStoredSchema,
+	scheduleHydrationOverride?: HydrationScheduler,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
 	const mapTree = unhydratedFlexTreeFromInsertable(data, schema);
 
 	const contentArray = mapTree === undefined ? [] : [mapTree];
-	validateAndPrepare(schemaAndPolicy, hydratedData, destinationSchema, contentArray);
+	validateAndPrepare(
+		schemaAndPolicy,
+		hydratedData,
+		destinationSchema,
+		contentArray,
+		scheduleHydrationOverride,
+	);
 
 	return mapTree;
 }
@@ -141,12 +151,19 @@ function validateAndPrepare(
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
 	fieldSchema: TreeFieldStoredSchema,
 	mapTrees: readonly UnhydratedFlexTreeNode[],
+	scheduleHydrationOverride?: HydrationScheduler,
 ): void {
 	if (hydratedData !== undefined) {
 		// Run `prepareContentForHydration` before walking the tree in `isFieldInSchema`.
 		// This ensures that when `isFieldInSchema` requests identifiers (or any other contextual defaults),
 		// they were already creating used the more specific context we have access to from `hydratedData`.
-		prepareContentForHydration(mapTrees, hydratedData.checkout.forest, hydratedData);
+		prepareContentForHydration(
+			mapTrees,
+			scheduleHydrationOverride ??
+				((batch, doHydration) =>
+					scheduleHydration(batch, hydratedData.checkout.forest, doHydration)),
+			hydratedData,
+		);
 		// TODO: AB#45723
 		// Now that staged schema rely on this validation, its a bit odd we don't do it for insertion into unhydrated contexts.
 		// We can't simply enable it for them however due to contextual default fields which would not have been created yet (see comment above).
@@ -157,15 +174,6 @@ function validateAndPrepare(
 	}
 }
 
-/**
- * An {@link UpPath} that is just index zero in a {@link DetachedField} which can be modified at a later time.
- */
-interface Root extends UpPath {
-	readonly parent: undefined;
-	parentField: DetachedField & FieldKey;
-	readonly parentIndex: NodeIndex & 0;
-}
-
 /**
  * The path from the included node to the root of the content tree it was inserted as part of.
  */
@@ -181,7 +189,7 @@ interface LocatedNodesBatch {
 	/**
 	 * UpPath shared by all {@link RelativeNodePath}s in this batch corresponding to the root of the inserted content.
 	 */
-	readonly rootPath: Root;
+	readonly rootPath: Mutable<UpPath>;
 	readonly paths: RelativeNodePath[];
 }
 
@@ -204,7 +212,7 @@ const placeholderKey: DetachedField & FieldKey = brand("placeholder" as const);
  */
 export function prepareContentForHydration(
 	content: readonly UnhydratedFlexTreeNode[],
-	forest: IForestSubscription,
+	scheduler: HydrationScheduler,
 	context: FlexTreeHydratedContextMinimal,
 ): void {
 	const batches: LocatedNodesBatch[] = [];
@@ -228,7 +236,8 @@ export function prepareContentForHydration(
 		);
 	}
 
-	scheduleHydration(batches, forest);
+	const doHydration = hydrator(batches, context.checkout.forest);
+	scheduler(batches, doHydration);
 }
 
 function walkMapTree(
@@ -270,6 +279,23 @@ function walkMapTree(
 	}
 }
 
+/**
+ * A function which can schedule hydration of batches of nodes to occur at a later time (which must be after they have been inserted into the tree).
+ */
+type HydrationScheduler = (
+	locatedNodes: readonly LocatedNodesBatch[],
+	/**
+	 * Does the actual hydration. Should be called for each index in `locatedNodes` once the corresponding content has been inserted into the tree.
+	 */
+	doHydration: Hydrator,
+) => void;
+
+/**
+ * Does the actual hydration.
+ * The provided `attachPath` is the path the content is currently under (where it was attached in the tree).
+ */
+type Hydrator = (batch: LocatedNodesBatch, attachPath: UpPath) => void;
+
 /**
  * Register events which will hydrate batches of nodes when they are inserted.
  * The next edits to forest must be their insertions, in order, or data corruption can occur.
@@ -280,22 +306,58 @@ function walkMapTree(
 function scheduleHydration(
 	locatedNodes: readonly LocatedNodesBatch[],
 	forest: IForestSubscription,
+	doHydration: Hydrator,
 ): void {
 	// Only subscribe to the event if there is at least one TreeNode tree to hydrate - this is not the case when inserting an empty array [].
 	if (locatedNodes.length > 0) {
 		// Creating a new array emits one event per element in the array, so listen to the event once for each element
-		let i = 0;
+		let index = 0;
 		const off = forest.events.on("afterRootFieldCreated", (fieldKey) => {
 			// Indexing is safe here because of the length check above. This assumes the array has not been modified which should be the case.
-			const batch = locatedNodes[i] ?? oob();
-			debugAssert(() => batch.rootPath.parentField === placeholderKey);
-			batch.rootPath.parentField = brand(fieldKey);
-			for (const { path, node } of batch.paths) {
-				getKernel(node).hydrate(forest.anchors, path);
-			}
-			if (++i === locatedNodes.length) {
+			const batch = locatedNodes[index] ?? oob();
+			doHydration(batch, { parent: undefined, parentField: fieldKey, parentIndex: 0 });
+			if (++index === locatedNodes.length) {
 				off();
 			}
 		});
 	}
 }
+
+/**
+ * Implementation of {@link Hydrator}.
+ */
+function hydrator(
+	locatedNodes: readonly LocatedNodesBatch[],
+	forest: IForestSubscription,
+): (batch: LocatedNodesBatch, attachedPath: UpPath) => void {
+	return (batch: LocatedNodesBatch, attachedPath: UpPath) => {
+		const context = forest.anchors.slots.get(ContextSlot) ?? fail(0xb41 /* missing context */);
+
+		// Modify paths in batch to point to correct location:
+		debugAssert(() => batch.rootPath.parentField === placeholderKey);
+		batch.rootPath.parentField = attachedPath.parentField;
+		batch.rootPath.parent = attachedPath.parent;
+		batch.rootPath.parentIndex = attachedPath.parentIndex;
+
+		// To hydrate a TreeNode, it must be associated with a HydratedFlexTreeNode.
+		// Find or create one as necessary.
+		for (const { path, node } of batch.paths) {
+			const anchor = forest.anchors.track(path);
+			const anchorNode = forest.anchors.locate(anchor) ?? fail(0xc7b /* missing anchor */);
+
+			let flexNode = anchorNode.slots.get(flexTreeSlot);
+			if (flexNode === undefined) {
+				// the flex node must be created
+				const cursor = forest.allocateCursor("getFlexNode");
+				forest.moveCursorToPath(anchorNode, cursor);
+
+				flexNode = getOrCreateHydratedFlexTreeNode(context, cursor);
+				cursor.free();
+				assertFlexTreeEntityNotFreed(flexNode);
+			}
+
+			getKernel(node).hydrate(flexNode);
+			forest.anchors.forget(anchor);
+		}
+	};
+}

package/src/treeFactory.ts

@@ -49,10 +49,23 @@ function treeKernelFactory(
 		if (args.idCompressor === undefined) {
 			throw new UsageError("IdCompressor must be enabled to use SharedTree");
 		}
-		const adjustedOptions = { ...options };
-		// TODO: get default from runtime once something like runtime.oldestCompatibleClient exists.
-		// Using default of 2.0 since that is the oldest version that supports SharedTree.
-		adjustedOptions.oldestCompatibleClient ??= FluidClientVersion.v2_0;
+
+		const { minVersionForCollab, ...otherOptions } = options;
+
+		const adjustedOptions = {
+			...otherOptions,
+			// Cases:
+			// A. If options specifies minVersionForCollab, it takes precedence over args.minVersionForCollab.
+			// This value is set when:
+			// - A customer using the declarative SharedTree API specifies the setting at the Shared Tree level.
+			//   There is currently no way to set it via the declarative API, but it could be added in the future.
+			// - treeKernelFactory is invoked in a fuzz test with a specific minVersionForCollab
+			// B. Otherwise, we use args.minVersionForCollab, which is propagated from the ContainerRuntime.
+			// C. If neither specifies it, we fall back to a default value default of 2.0 since that is the oldest version that supports SharedTree.
+			minVersionForCollab:
+				minVersionForCollab ?? args.minVersionForCollab ?? FluidClientVersion.v2_0,
+		};
+
 		return new SharedTreeKernel(
 			new Breakable("SharedTree"),
 			args.sharedObject,