@fluidframework/tree 2.74.0-365691 → 2.74.0

package/src/feature-libraries/schema-index/schemaSummarizer.ts

@@ -9,10 +9,10 @@ import type { IChannelStorageService } from "@fluidframework/datastore-definitio
 import { SummaryType } from "@fluidframework/driver-definitions";
 import type {
 	IExperimentalIncrementalSummaryContext,
-	ISummaryTreeWithStats,
 	ITelemetryContext,
+	MinimumVersionForCollab,
 } from "@fluidframework/runtime-definitions/internal";
-import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
+import type { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 
 import type { IJsonCodec } from "../../codec/index.js";
 import {
@@ -21,30 +21,73 @@ import {
 	type TreeStoredSchema,
 	schemaDataIsEmpty,
 } from "../../core/index.js";
-import type {
-	Summarizable,
-	SummaryElementParser,
-	SummaryElementStringifier,
+import {
+	VersionedSummarizer,
+	type Summarizable,
+	type SummaryElementParser,
+	type SummaryElementStringifier,
 } from "../../shared-tree-core/index.js";
 import type { JsonCompatible } from "../../util/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
 import { encodeRepo } from "./codec.js";
 
-const schemaStringKey = "SchemaString";
+export const schemaStringKey = "SchemaString";
+
 /**
- * Provides methods for summarizing and loading a schema repository.
+ * The versions for the schema summary format.
+ */
+export const enum SchemaSummaryFormatVersion {
+	/**
+	 * This version represents summary format before summary versioning was introduced.
+	 */
+	v1 = 1,
+	/**
+	 * This version adds metadata to the summary. This is backward compatible with version 1.
+	 */
+	v2 = 2,
+	/**
+	 * The latest version of the summary. Must be updated when a new version is added.
+	 */
+	vLatest = v2,
+}
+
+const supportedVersions = new Set<SchemaSummaryFormatVersion>([
+	SchemaSummaryFormatVersion.v1,
+	SchemaSummaryFormatVersion.v2,
+]);
+
+/**
+ * Returns the summary version to use as per the given minimum version for collab.
  */
-export class SchemaSummarizer implements Summarizable {
-	public readonly key = "Schema";
+function minVersionToSchemaSummaryFormatVersion(
+	version: MinimumVersionForCollab,
+): SchemaSummaryFormatVersion {
+	// Currently, version 2 is written which adds metadata blob to the summary.
+	return SchemaSummaryFormatVersion.v2;
+}
 
+/**
+ * Provides methods for summarizing and loading a schema repository.
+ */
+export class SchemaSummarizer
+	extends VersionedSummarizer<SchemaSummaryFormatVersion>
+	implements Summarizable
+{
 	private schemaIndexLastChangedSeq: number | undefined;
 
 	public constructor(
 		private readonly schema: MutableTreeStoredSchema,
 		collabWindow: CollabWindow,
 		private readonly codec: IJsonCodec<TreeStoredSchema>,
+		minVersionForCollab: MinimumVersionForCollab,
 	) {
+		super(
+			"Schema",
+			minVersionToSchemaSummaryFormatVersion(minVersionForCollab),
+			supportedVersions,
+			true /* supportPreVersioningFormat */,
+		);
 		this.schema.events.on("afterSchemaChange", () => {
 			// Invalidate the cache, as we need to regenerate the blob if the schema changes
 			// We are assuming that schema changes from remote ops are valid, as we are in a summarization context.
@@ -52,16 +95,15 @@ export class SchemaSummarizer implements Summarizable {
 		});
 	}
 
-	public summarize(props: {
+	protected summarizeInternal(props: {
 		stringify: SummaryElementStringifier;
 		fullTree?: boolean;
 		trackState?: boolean;
 		telemetryContext?: ITelemetryContext;
 		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
-	}): ISummaryTreeWithStats {
-		const incrementalSummaryContext = props.incrementalSummaryContext;
-		const builder = new SummaryTreeBuilder();
-		const fullTree = props.fullTree ?? false;
+		builder: SummaryTreeBuilder;
+	}): void {
+		const { builder, incrementalSummaryContext, stringify, fullTree = false } = props;
 		if (
 			!fullTree &&
 			incrementalSummaryContext !== undefined &&
@@ -74,13 +116,12 @@ export class SchemaSummarizer implements Summarizable {
 				`${incrementalSummaryContext.summaryPath}/${schemaStringKey}`,
 			);
 		} else {
-			const dataString = JSON.stringify(this.codec.encode(this.schema));
+			const dataString = stringify(this.codec.encode(this.schema));
 			builder.addBlob(schemaStringKey, dataString);
 		}
-		return builder.getSummaryTree();
 	}
 
-	public async load(
+	protected async loadInternal(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,
 	): Promise<void> {

package/src/index.ts

@@ -9,6 +9,7 @@ export {
 	CommitKind,
 	RevertibleStatus,
 	type CommitMetadata,
+	type ChangeMetadata,
 	type RevertibleFactory,
 	type RevertibleAlphaFactory,
 	type RevertibleAlpha,
@@ -185,6 +186,7 @@ export {
 	type AnnotateAllowedTypesList,
 	type AllowedTypesFull,
 	type AllowedTypesFullFromMixed,
+	type SchemaType,
 	// Beta APIs
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -283,13 +285,15 @@ export {
 	type SchemaFactory_base,
 	type NumberKeys,
 	type SimpleAllowedTypeAttributes,
-	encodeSimpleSchema,
-	decodeSimpleSchema,
+	encodeSchemaCompatibilitySnapshot,
+	decodeSchemaCompatibilitySnapshot,
 	exportCompatibilitySchemaSnapshot,
 	importCompatibilitySchemaSnapshot,
 	checkCompatibility,
 	incrementalSummaryHint,
 	incrementalEncodingPolicyForAllowedTypes,
+	eraseSchemaDetails,
+	eraseSchemaDetailsSubclassable,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,

package/src/packageVersion.ts

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

package/src/shared-tree/independentView.ts

@@ -48,7 +48,6 @@ import {
 	type JsonCompatible,
 	Breakable,
 	oneFromIterable,
-	brand,
 } from "../util/index.js";
 import {
 	buildConfiguredForest,
@@ -72,7 +71,7 @@ import { combineChunks } from "../feature-libraries/index.js";
  */
 export function independentView<const TSchema extends ImplicitFieldSchema>(
 	config: TreeViewConfiguration<TSchema>,
-	options: ForestOptions & { idCompressor?: IIdCompressor | undefined },
+	options?: ForestOptions & { idCompressor?: IIdCompressor | undefined },
 ): TreeViewAlpha<TSchema> {
 	return createIndependentTreeAlpha(options).viewWith(config) as TreeViewAlpha<TSchema>;
 }
@@ -206,7 +205,7 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 			...options,
 			minVersionForCollab: FluidClientVersion.v2_0,
 		};
-		const schemaCodec = makeSchemaCodec(writeOptions, brand(SchemaFormatVersion.v1));
+		const schemaCodec = makeSchemaCodec(writeOptions, SchemaFormatVersion.v1);
 		const fieldBatchCodec = makeFieldBatchCodec(writeOptions);
 		const newSchema = schemaCodec.decode(options.content.schema as Format);
 

package/src/shared-tree/schematizingTreeView.ts

@@ -66,6 +66,7 @@ import {
 	type Breakable,
 	breakingClass,
 	disposeSymbol,
+	type JsonCompatibleReadOnly,
 	type WithBreakable,
 } from "../util/index.js";
 
@@ -165,6 +166,10 @@ export class SchematizingSimpleTreeView<
 		);
 	}
 
+	public applyChange(change: JsonCompatibleReadOnly): void {
+		this.checkout.applySerializedChange(change);
+	}
+
 	public hasRootSchema<TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
 	): this is TreeViewAlpha<TSchema> {

package/src/shared-tree/sharedTree.ts

@@ -97,6 +97,7 @@ import {
 	type ITreeAlpha,
 	type SimpleObjectFieldSchema,
 	type SimpleAllowedTypeAttributes,
+	type SchemaType,
 } from "../simple-tree/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
@@ -240,6 +241,7 @@ export class SharedTreeKernel
 				getCurrentSeq: lastSequenceNumber,
 			},
 			schemaCodec,
+			options.minVersionForCollab,
 		);
 		const fieldBatchCodec = makeFieldBatchCodec(options);
 
@@ -262,7 +264,10 @@ export class SharedTreeKernel
 			initialSequenceNumber,
 			options.shouldEncodeIncrementally,
 		);
-		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(removedRoots);
+		const removedRootsSummarizer = new DetachedFieldIndexSummarizer(
+			removedRoots,
+			options.minVersionForCollab,
+		);
 		const innerChangeFamily = new SharedTreeChangeFamily(
 			revisionTagCodec,
 			fieldBatchCodec,
@@ -503,7 +508,9 @@ export class SharedTreeKernel
 	public onDisconnect(): void {}
 }
 
-export function exportSimpleSchema(storedSchema: TreeStoredSchema): SimpleTreeSchema {
+export function exportSimpleSchema(
+	storedSchema: TreeStoredSchema,
+): SimpleTreeSchema<SchemaType.Stored> {
 	return {
 		root: exportSimpleFieldSchemaStored(storedSchema.rootFieldSchema),
 		definitions: new Map(
@@ -589,7 +596,7 @@ export const changeFormatVersionForEditManager = DependentFormatVersion.fromPair
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v5),
+		brand<EditManagerFormatVersion>(EditManagerFormatVersion.vSharedBranches),
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 ]);
@@ -610,7 +617,7 @@ export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<MessageFormatVersion>(MessageFormatVersion.v5),
+		brand<MessageFormatVersion>(MessageFormatVersion.vSharedBranches),
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 ]);
@@ -819,8 +826,8 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
  */
 function buildSimpleAllowedTypeAttributesForStoredSchema(
 	types: TreeTypeSet,
-): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
-	const allowedTypesInfo = new Map<string, SimpleAllowedTypeAttributes>();
+): ReadonlyMap<string, SimpleAllowedTypeAttributes<SchemaType.Stored>> {
+	const allowedTypesInfo = new Map<string, SimpleAllowedTypeAttributes<SchemaType.Stored>>();
 	for (const type of types) {
 		// Stored schemas do not have staged upgrades
 		allowedTypesInfo.set(type, { isStaged: undefined });
@@ -828,7 +835,9 @@ function buildSimpleAllowedTypeAttributesForStoredSchema(
 	return allowedTypesInfo;
 }
 
-function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFieldSchema {
+function exportSimpleFieldSchemaStored(
+	schema: TreeFieldStoredSchema,
+): SimpleFieldSchema<SchemaType.Stored> {
 	let kind: FieldKind;
 	switch (schema.kind) {
 		case FieldKinds.identifier.identifier:
@@ -862,7 +871,9 @@ function exportSimpleFieldSchemaStored(schema: TreeFieldStoredSchema): SimpleFie
  * Note on SimpleNodeSchema construction: In the persisted format `persistedMetadata` is just called `metadata` whereas the `metadata`
  * field on SimpleNodeSchema is not persisted.
  */
-function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeSchema {
+function exportSimpleNodeSchemaStored(
+	schema: TreeNodeStoredSchema,
+): SimpleNodeSchema<SchemaType.Stored> {
 	const arrayTypes = tryStoredSchemaAsArray(schema);
 	if (arrayTypes !== undefined) {
 		return {
@@ -873,7 +884,7 @@ function exportSimpleNodeSchemaStored(schema: TreeNodeStoredSchema): SimpleNodeS
 		};
 	}
 	if (schema instanceof ObjectNodeStoredSchema) {
-		const fields = new Map<FieldKey, SimpleObjectFieldSchema>();
+		const fields = new Map<FieldKey, SimpleObjectFieldSchema<SchemaType.Stored>>();
 		for (const [storedKey, field] of schema.objectNodeFields) {
 			fields.set(storedKey, { ...exportSimpleFieldSchemaStored(field), storedKey });
 		}

package/src/shared-tree/sharedTreeChangeCodecs.ts

@@ -86,8 +86,8 @@ export const dependenciesForChangeFormat: Map<
 	SharedTreeChangeFormatVersion,
 	ChangeFormatDependencies
 > = new Map([
-	[brand(3), { modularChange: brand(3), schemaChange: brand(SchemaFormatVersion.v1) }],
-	[brand(4), { modularChange: brand(4), schemaChange: brand(SchemaFormatVersion.v1) }],
+	[brand(3), { modularChange: brand(3), schemaChange: SchemaFormatVersion.v1 }],
+	[brand(4), { modularChange: brand(4), schemaChange: SchemaFormatVersion.v1 }],
 ]);
 
 export function getCodecTreeForChangeFormat(

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -9,6 +9,8 @@ import {
 	type DeltaDetachedNodeId,
 	type DetachedFieldIndex,
 	type IEditableForest,
+	type IForestSubscription,
+	type ReadOnlyDetachedFieldIndex,
 	type RevisionTag,
 	type TreeStoredSchemaRepository,
 	tagChange,
@@ -35,24 +37,25 @@ export class SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherReadonlyCheckout<SharedTreeChange>
 {
 	/**
-	 * @param forest - The state based on which to enrich changes.
-	 * Exclusively owned by the constructed instance.
+	 * @param borrowedForest - The state based on which to enrich changes.
+	 * Not owned by the constructed instance.
 	 * @param schema - The schema that corresponds to the forest.
-	 * @param removedRoots - The set of removed roots based on which to enrich changes.
-	 * Exclusively owned by the constructed instance.
+	 * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.
+	 * Not owned by the constructed instance.
+	 * @param idCompressor - The id compressor to use when chunking trees.
 	 */
 	public constructor(
-		protected readonly forest: IEditableForest,
+		protected readonly borrowedForest: IForestSubscription,
 		private readonly schema: TreeStoredSchemaRepository,
-		protected readonly removedRoots: DetachedFieldIndex,
+		protected readonly borrowedRemovedRoots: ReadOnlyDetachedFieldIndex,
 		private readonly idCompressor?: IIdCompressor,
 	) {}
 
 	public fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {
 		return new SharedTreeMutableChangeEnricher(
-			this.forest.clone(this.schema, new AnchorSet()),
+			this.borrowedForest.clone(this.schema, new AnchorSet()),
 			this.schema,
-			this.removedRoots.clone(),
+			this.borrowedRemovedRoots.clone(),
 		);
 	}
 
@@ -66,10 +69,10 @@ export class SharedTreeReadonlyChangeEnricher
 	}
 
 	private readonly getDetachedRoot = (id: DeltaDetachedNodeId): TreeChunk | undefined => {
-		const root = this.removedRoots.tryGetEntry(id);
+		const root = this.borrowedRemovedRoots.tryGetEntry(id);
 		if (root !== undefined) {
-			const cursor = this.forest.getCursorAboveDetachedFields();
-			const parentField = this.removedRoots.toFieldKey(root);
+			const cursor = this.borrowedForest.getCursorAboveDetachedFields();
+			const parentField = this.borrowedRemovedRoots.toFieldKey(root);
 			cursor.enterField(parentField);
 			cursor.enterNode(0);
 			return chunkTree(cursor, {
@@ -85,6 +88,23 @@ export class SharedTreeMutableChangeEnricher
 	extends SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherMutableCheckout<SharedTreeChange>
 {
+	/**
+	 * @param forest - The state based on which to enrich changes.
+	 * Owned by the constructed instance.
+	 * @param schema - The schema that corresponds to the forest.
+	 * @param removedRoots - The set of removed roots based on which to enrich changes.
+	 * Owned by the constructed instance.
+	 * @param idCompressor - The id compressor to use when chunking trees.
+	 */
+	public constructor(
+		private readonly forest: IEditableForest,
+		schema: TreeStoredSchemaRepository,
+		private readonly removedRoots: DetachedFieldIndex,
+		idCompressor?: IIdCompressor,
+	) {
+		super(forest, schema, removedRoots, idCompressor);
+	}
+
 	public applyTipChange(change: SharedTreeChange, revision?: RevisionTag): void {
 		for (const dataOrSchemaChange of change.changes) {
 			const type = dataOrSchemaChange.type;

package/src/shared-tree/treeAlpha.ts

@@ -50,8 +50,6 @@ import {
 	isObjectNodeSchema,
 	isTreeNode,
 	toInitialSchema,
-	convertField,
-	toUnhydratedSchema,
 	type TreeParsingOptions,
 	type NodeChangedData,
 	type ConciseTree,
@@ -60,6 +58,7 @@ import {
 	borrowCursorFromTreeNodeOrValue,
 	contentSchemaSymbol,
 	type TreeNodeSchema,
+	getUnhydratedContext,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -824,7 +823,7 @@ export const TreeAlpha: TreeAlpha = {
 		return createFromCursor(
 			schema,
 			cursor,
-			convertField(normalizeFieldSchema(schema), toUnhydratedSchema),
+			getUnhydratedContext(schema).flexContext.schema.rootFieldSchema,
 		);
 	},