@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -7,26 +7,26 @@ import {
 	DeltaDetachedNodeId,
 	DeltaFieldChanges,
 	DeltaMark,
-	makeAnonChange,
 	RevisionMetadataSource,
 	TaggedChange,
+	makeAnonChange,
+	Multiplicity,
 } from "../../core/index.js";
-import { fail, IdAllocator } from "../../util/index.js";
-import { Multiplicity } from "../multiplicity.js";
+import { IdAllocator, fail } from "../../util/index.js";
+
 import { CrossFieldManager } from "./crossFieldQueries.js";
 import {
 	FieldChangeHandler,
-	ToDelta,
 	NodeChangeComposer,
-	NodeChangeInverter,
+	NodeChangePruner,
 	NodeChangeRebaser,
 	RelevantRemovedRootsFromChild,
-	NodeChangePruner,
+	ToDelta,
 } from "./fieldChangeHandler.js";
 import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
-import { GenericChange, GenericChangeset } from "./genericFieldKindTypes.js";
-import { NodeChangeset } from "./modularChangeTypes.js";
+import { GenericChangeset } from "./genericFieldKindTypes.js";
+import { NodeId } from "./modularChangeTypes.js";
 
 /**
  * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.
@@ -72,16 +72,8 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 			}
 			return composed;
 		},
-		invert: (
-			{ change }: TaggedChange<GenericChangeset>,
-			invertChild: NodeChangeInverter,
-		): GenericChangeset => {
-			return change.map(
-				({ index, nodeChange }: GenericChange): GenericChange => ({
-					index,
-					nodeChange: invertChild(nodeChange),
-				}),
-			);
+		invert: ({ change }: TaggedChange<GenericChangeset>): GenericChangeset => {
+			return change;
 		},
 		rebase: rebaseGenericChange,
 		prune: pruneGenericChange,
@@ -127,8 +119,8 @@ function rebaseGenericChange(
 		const b = over[iOver];
 		const aIndex = a?.index ?? Infinity;
 		const bIndex = b?.index ?? Infinity;
-		let nodeChangeA: NodeChangeset | undefined;
-		let nodeChangeB: NodeChangeset | undefined;
+		let nodeChangeA: NodeId | undefined;
+		let nodeChangeB: NodeId | undefined;
 		let index: number;
 		if (aIndex === bIndex) {
 			index = a.index;

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

@@ -3,60 +3,47 @@
  * Licensed under the MIT License.
  */
 
-import { Type } from "@sinclair/typebox";
 import { ICodecFamily, IJsonCodec, makeCodecFamily } from "../../codec/index.js";
-import { JsonCompatibleReadOnly } from "../../util/index.js";
-import { ChangeEncodingContext } from "../../core/index.js";
-import type { NodeChangeset } from "../modular-schema/index.js";
+import { FieldChangeEncodingContext } from "./fieldChangeHandler.js";
 import { EncodedGenericChange, EncodedGenericChangeset } from "./genericFieldKindFormat.js";
 import type { GenericChange, GenericChangeset } from "./genericFieldKindTypes.js";
+import { EncodedNodeChangeset } from "./modularChangeFormat.js";
 
-export function makeGenericChangeCodec<TChildChange = NodeChangeset>(
-	childCodec: IJsonCodec<
-		TChildChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
-): ICodecFamily<GenericChangeset<TChildChange>, ChangeEncodingContext> {
-	return makeCodecFamily([[0, makeV0Codec(childCodec)]]);
+export function makeGenericChangeCodec(): ICodecFamily<
+	GenericChangeset,
+	FieldChangeEncodingContext
+> {
+	return makeCodecFamily([[1, makeV1Codec()]]);
 }
 
-function makeV0Codec<TChildChange = NodeChangeset>(
-	childCodec: IJsonCodec<
-		TChildChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
-): IJsonCodec<
-	GenericChangeset<TChildChange>,
+function makeV1Codec(): IJsonCodec<
+	GenericChangeset,
 	EncodedGenericChangeset,
 	EncodedGenericChangeset,
-	ChangeEncodingContext
+	FieldChangeEncodingContext
 > {
 	return {
 		encode: (
-			change: GenericChangeset<TChildChange>,
-			context: ChangeEncodingContext,
+			change: GenericChangeset,
+			context: FieldChangeEncodingContext,
 		): EncodedGenericChangeset => {
 			const encoded: EncodedGenericChangeset = change.map(({ index, nodeChange }) => [
 				index,
-				childCodec.encode(nodeChange, context),
+				context.encodeNode(nodeChange),
 			]);
 			return encoded;
 		},
 		decode: (
 			encoded: EncodedGenericChangeset,
-			context: ChangeEncodingContext,
-		): GenericChangeset<TChildChange> => {
+			context: FieldChangeEncodingContext,
+		): GenericChangeset => {
 			return encoded.map(
-				([index, nodeChange]: EncodedGenericChange): GenericChange<TChildChange> => ({
+				([index, nodeChange]: EncodedGenericChange): GenericChange => ({
 					index,
-					nodeChange: childCodec.decode(nodeChange, context),
+					nodeChange: context.decodeNode(nodeChange),
 				}),
 			);
 		},
-		encodedSchema: EncodedGenericChangeset(childCodec.encodedSchema ?? Type.Any()),
+		encodedSchema: EncodedGenericChangeset(EncodedNodeChangeset),
 	};
 }

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { Static, Type, TSchema, TAnySchema } from "@sinclair/typebox";
+import { Static, TAnySchema, TSchema, Type } from "@sinclair/typebox";
 
 /**
  * Note: TS doesn't easily support extracting a generic function's return type until 4.7:
@@ -23,7 +23,7 @@ class Wrapper<T extends TSchema> {
 
 export const EncodedGenericChange = <NodeChangesetSchema extends TSchema>(
 	tNodeChangeset: NodeChangesetSchema,
-) => Type.Tuple([Type.Number({ minimum: 0 }), tNodeChangeset]);
+) => Type.Tuple([Type.Number({ minimum: 0, multipleOf: 1 }), tNodeChangeset]);
 
 export type EncodedGenericChange<Schema extends TSchema = TAnySchema> = Static<
 	ReturnType<Wrapper<Schema>["encodedGenericChange"]>

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

@@ -3,12 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { NodeChangeset } from "./modularChangeTypes.js";
+import { NodeId } from "./modularChangeTypes.js";
 
 /**
  * A field-kind-agnostic change to a single node within a field.
  */
-export interface GenericChange<TChildChange = NodeChangeset> {
+export interface GenericChange {
 	/**
 	 * Index within the field of the changed node.
 	 */
@@ -16,10 +16,10 @@ export interface GenericChange<TChildChange = NodeChangeset> {
 	/**
 	 * Change to the node.
 	 */
-	nodeChange: TChildChange;
+	nodeChange: NodeId;
 }
 
 /**
  * A field-agnostic set of changes to the elements of a field.
  */
-export type GenericChangeset<TChildChange = NodeChangeset> = GenericChange<TChildChange>[];
+export type GenericChangeset = GenericChange[];

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

@@ -23,6 +23,7 @@ export {
 	EncodedChangeAtomId,
 	EncodedRevisionInfo,
 	EncodedModularChangeset,
+	EncodedNodeChangeset,
 } from "./modularChangeFormat.js";
 export { FlexFieldKind, FullSchemaPolicy } from "./fieldKind.js";
 export { FieldKindWithEditor } from "./fieldKindWithEditor.js";
@@ -40,6 +41,7 @@ export {
 	RelevantRemovedRootsFromChild,
 	ToDelta,
 	NodeExistenceState,
+	FieldChangeEncodingContext,
 } from "./fieldChangeHandler.js";
 export {
 	FieldChange,
@@ -47,8 +49,8 @@ export {
 	FieldChangeset,
 	HasFieldChanges,
 	ModularChangeset,
-	NodeChangeset,
 	NodeExistsConstraint,
+	NodeId,
 } from "./modularChangeTypes.js";
 export {
 	convertGenericChange,
@@ -66,4 +68,5 @@ export {
 	intoDelta,
 	relevantRemovedRoots,
 } from "./modularChangeFamily.js";
-export { makeV0Codec } from "./modularChangeCodecs.js";
+export { makeModularChangeCodecFamily } from "./modularChangeCodecs.js";
+export { FieldKindConfiguration, FieldKindConfigurationEntry } from "./fieldKindConfiguration.js";

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

@@ -3,17 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
-import { fail } from "../../util/index.js";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import {
-	TreeNodeStoredSchema,
-	TreeFieldStoredSchema,
-	TreeStoredSchema,
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
 	ObjectNodeStoredSchema,
+	TreeFieldStoredSchema,
+	TreeNodeStoredSchema,
+	TreeStoredSchema,
+	Multiplicity,
 } from "../../core/index.js";
-import { Multiplicity } from "../multiplicity.js";
+import { fail } from "../../util/index.js";
+
 import { FullSchemaPolicy } from "./fieldKind.js";
 
 /**
@@ -35,8 +37,8 @@ export function isNeverFieldRecursive(
 	parentTypeStack: Set<TreeNodeStoredSchema>,
 ): boolean {
 	if (
-		(policy.fieldKinds.get(field.kind.identifier) ?? fail("missing field kind"))
-			.multiplicity === Multiplicity.Single &&
+		(policy.fieldKinds.get(field.kind) ?? fail("missing field kind")).multiplicity ===
+			Multiplicity.Single &&
 		field.types !== undefined
 	) {
 		for (const type of field.types) {
@@ -94,10 +96,8 @@ export function isNeverTreeRecursive(
 		parentTypeStack.add(treeNode);
 		if (treeNode instanceof MapNodeStoredSchema) {
 			return (
-				(
-					policy.fieldKinds.get(treeNode.mapFields.kind.identifier) ??
-					fail("missing field kind")
-				).multiplicity === Multiplicity.Single
+				(policy.fieldKinds.get(treeNode.mapFields.kind) ?? fail("missing field kind"))
+					.multiplicity === Multiplicity.Single
 			);
 		} else if (treeNode instanceof ObjectNodeStoredSchema) {
 			for (const field of treeNode.objectNodeFields.values()) {

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

@@ -3,26 +3,39 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/core-utils/internal";
 import { TAnySchema } from "@sinclair/typebox";
-import { assert } from "@fluidframework/core-utils";
+
 import {
-	ChangesetLocalId,
+	type ICodecFamily,
+	ICodecOptions,
+	IJsonCodec,
+	IMultiFormatCodec,
+	SchemaValidationFunction,
+	makeCodecFamily,
+	withSchemaValidation,
+} from "../../codec/index.js";
+import {
+	ChangeAtomIdMap,
 	ChangeEncodingContext,
+	ChangesetLocalId,
 	EncodedRevisionTag,
 	FieldKey,
 	FieldKindIdentifier,
 	ITreeCursorSynchronous,
 	RevisionInfo,
 	RevisionTag,
-	ChangeAtomIdMap,
 } from "../../core/index.js";
-import { brand, fail, JsonCompatibleReadOnly, Mutable } from "../../util/index.js";
 import {
-	ICodecOptions,
-	IJsonCodec,
-	IMultiFormatCodec,
-	SchemaValidationFunction,
-} from "../../codec/index.js";
+	IdAllocator,
+	JsonCompatibleReadOnly,
+	Mutable,
+	brand,
+	fail,
+	idAllocatorFromMaxId,
+	setInNestedMap,
+	tryGetFromNestedMap,
+} from "../../util/index.js";
 import {
 	FieldBatchCodec,
 	TreeChunk,
@@ -30,13 +43,8 @@ import {
 	defaultChunkPolicy,
 } from "../chunked-forest/index.js";
 import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
-import {
-	FieldChangeMap,
-	FieldChangeset,
-	ModularChangeset,
-	NodeChangeset,
-} from "./modularChangeTypes.js";
-import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
+
+import { FieldKindConfiguration, FieldKindConfigurationEntry } from "./fieldKindConfiguration.js";
 import { genericFieldKind } from "./genericFieldKind.js";
 import {
 	EncodedBuilds,
@@ -47,9 +55,17 @@ import {
 	EncodedNodeChangeset,
 	EncodedRevisionInfo,
 } from "./modularChangeFormat.js";
+import {
+	FieldChangeMap,
+	FieldChangeset,
+	ModularChangeset,
+	NodeChangeset,
+	NodeId,
+} from "./modularChangeTypes.js";
+import { FieldChangeEncodingContext } from "./fieldChangeHandler.js";
 
-export function makeV0Codec(
-	fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor>,
+export function makeModularChangeCodecFamily(
+	fieldKindConfigurations: ReadonlyMap<number, FieldKindConfiguration>,
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
@@ -59,27 +75,49 @@ export function makeV0Codec(
 	fieldsCodec: FieldBatchCodec,
 	{ jsonValidator: validator }: ICodecOptions,
 	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
-): IJsonCodec<
+): ICodecFamily<ModularChangeset, ChangeEncodingContext> {
+	return makeCodecFamily(
+		Array.from(fieldKindConfigurations.entries(), ([version, fieldKinds]) => [
+			version,
+			makeModularChangeCodec(
+				fieldKinds,
+				revisionTagCodec,
+				fieldsCodec,
+				{ jsonValidator: validator },
+				chunkCompressionStrategy,
+			),
+		]),
+	);
+}
+
+type ModularChangeCodec = IJsonCodec<
 	ModularChangeset,
 	EncodedModularChangeset,
 	EncodedModularChangeset,
 	ChangeEncodingContext
-> {
-	const nodeChangesetCodec: IJsonCodec<
-		NodeChangeset,
-		EncodedNodeChangeset,
-		EncodedNodeChangeset,
-		ChangeEncodingContext
-	> = {
-		encode: encodeNodeChangesForJson,
-		decode: decodeNodeChangesetFromJson,
-		encodedSchema: EncodedNodeChangeset,
-	};
+>;
+
+type FieldCodec = IMultiFormatCodec<
+	FieldChangeset,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnly,
+	FieldChangeEncodingContext
+>;
 
-	const getMapEntry = (field: FieldKindWithEditor) => {
-		const codec = field.changeHandler
-			.codecsFactory(nodeChangesetCodec, revisionTagCodec)
-			.resolve(0);
+function makeModularChangeCodec(
+	fieldKinds: FieldKindConfiguration,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	fieldsCodec: FieldBatchCodec,
+	{ jsonValidator: validator }: ICodecOptions,
+	chunkCompressionStrategy: TreeCompressionStrategy = TreeCompressionStrategy.Compressed,
+): ModularChangeCodec {
+	const getMapEntry = ({ kind, formatVersion }: FieldKindConfigurationEntry) => {
+		const codec = kind.changeHandler.codecsFactory(revisionTagCodec).resolve(formatVersion);
 		return {
 			codec,
 			compiledSchema: codec.json.encodedSchema
@@ -88,23 +126,25 @@ export function makeV0Codec(
 		};
 	};
 
-	type FieldCodec = IMultiFormatCodec<
-		FieldChangeset,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>;
-
+	/**
+	 * The codec version for the generic field kind.
+	 */
+	const genericFieldKindFormatVersion = 1;
 	const fieldChangesetCodecs: Map<
 		FieldKindIdentifier,
 		{
 			compiledSchema?: SchemaValidationFunction<TAnySchema>;
 			codec: FieldCodec;
 		}
-	> = new Map([[genericFieldKind.identifier, getMapEntry(genericFieldKind)]]);
-
-	fieldKinds.forEach((fieldKind, identifier) => {
-		fieldChangesetCodecs.set(identifier, getMapEntry(fieldKind));
+	> = new Map([
+		[
+			genericFieldKind.identifier,
+			getMapEntry({ kind: genericFieldKind, formatVersion: genericFieldKindFormatVersion }),
+		],
+	]);
+
+	fieldKinds.forEach((entry, identifier) => {
+		fieldChangesetCodecs.set(identifier, getMapEntry(entry));
 	});
 
 	const getFieldChangesetCodec = (
@@ -121,8 +161,29 @@ export function makeV0Codec(
 	function encodeFieldChangesForJson(
 		change: FieldChangeMap,
 		context: ChangeEncodingContext,
+		nodeChanges: ChangeAtomIdMap<NodeChangeset>,
+	): EncodedFieldChangeMap {
+		const fieldContext: FieldChangeEncodingContext = {
+			baseContext: context,
+
+			encodeNode: (nodeId: NodeId): EncodedNodeChangeset => {
+				const node = tryGetFromNestedMap(nodeChanges, nodeId.revision, nodeId.localId);
+				assert(node !== undefined, 0x92e /* Unknown node ID */);
+				return encodeNodeChangesForJson(node, fieldContext);
+			},
+
+			decodeNode: () => fail("Should not decode nodes during field encoding"),
+		};
+
+		return encodeFieldChangesForJsonI(change, fieldContext);
+	}
+
+	function encodeFieldChangesForJsonI(
+		change: FieldChangeMap,
+		context: FieldChangeEncodingContext,
 	): EncodedFieldChangeMap {
 		const encodedFields: EncodedFieldChangeMap = [];
+
 		for (const [field, fieldChange] of change) {
 			const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind);
 			const encodedChange = codec.json.encode(fieldChange.change, context);
@@ -145,13 +206,13 @@ export function makeV0Codec(
 
 	function encodeNodeChangesForJson(
 		change: NodeChangeset,
-		context: ChangeEncodingContext,
+		context: FieldChangeEncodingContext,
 	): EncodedNodeChangeset {
 		const encodedChange: EncodedNodeChangeset = {};
 		const { fieldChanges, nodeExistsConstraint } = change;
 
 		if (fieldChanges !== undefined) {
-			encodedChange.fieldChanges = encodeFieldChangesForJson(fieldChanges, context);
+			encodedChange.fieldChanges = encodeFieldChangesForJsonI(fieldChanges, context);
 		}
 
 		if (nodeExistsConstraint !== undefined) {
@@ -164,6 +225,29 @@ export function makeV0Codec(
 	function decodeFieldChangesFromJson(
 		encodedChange: EncodedFieldChangeMap,
 		context: ChangeEncodingContext,
+		idAllocator: IdAllocator,
+	): [FieldChangeMap, ChangeAtomIdMap<NodeChangeset>] {
+		const decodedNodes: ChangeAtomIdMap<NodeChangeset> = new Map();
+		const fieldContext: FieldChangeEncodingContext = {
+			baseContext: context,
+
+			encodeNode: () => fail("Should not encode nodes during field decoding"),
+
+			decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
+				const node = decodeNodeChangesetFromJson(encodedNode, fieldContext);
+				const nodeId: NodeId = { localId: brand(idAllocator.allocate()) };
+				setInNestedMap(decodedNodes, nodeId.revision, nodeId.localId, node);
+				return nodeId;
+			},
+		};
+
+		const decodedFields = decodeFieldChangesFromJsonI(encodedChange, fieldContext);
+		return [decodedFields, decodedNodes];
+	}
+
+	function decodeFieldChangesFromJsonI(
+		encodedChange: EncodedFieldChangeMap,
+		context: FieldChangeEncodingContext,
 	): FieldChangeMap {
 		const decodedFields: FieldChangeMap = new Map();
 		for (const field of encodedChange) {
@@ -186,13 +270,13 @@ export function makeV0Codec(
 
 	function decodeNodeChangesetFromJson(
 		encodedChange: EncodedNodeChangeset,
-		context: ChangeEncodingContext,
+		context: FieldChangeEncodingContext,
 	): NodeChangeset {
 		const decodedChange: NodeChangeset = {};
 		const { fieldChanges, nodeExistsConstraint } = encodedChange;
 
 		if (fieldChanges !== undefined) {
-			decodedChange.fieldChanges = decodeFieldChangesFromJson(fieldChanges, context);
+			decodedChange.fieldChanges = decodeFieldChangesFromJsonI(fieldChanges, context);
 		}
 
 		if (nodeExistsConstraint !== undefined) {
@@ -306,8 +390,7 @@ export function makeV0Codec(
 		return decodedRevisions;
 	}
 
-	// TODO: use withSchemaValidation here to validate data against format.
-	return {
+	const modularChangeCodec: ModularChangeCodec = {
 		encode: (change, context) => {
 			// Destroys only exist in rollback changesets, which are never sent.
 			assert(change.destroys === undefined, 0x899 /* Unexpected changeset with destroys */);
@@ -317,16 +400,27 @@ export function makeV0Codec(
 					change.revisions === undefined
 						? change.revisions
 						: encodeRevisionInfos(change.revisions, context),
-				changes: encodeFieldChangesForJson(change.fieldChanges, context),
+				changes: encodeFieldChangesForJson(
+					change.fieldChanges,
+					context,
+					change.nodeChanges,
+				),
 				builds: encodeDetachedNodes(change.builds, context),
 				refreshers: encodeDetachedNodes(change.refreshers, context),
 			};
 		},
-		decode: (change, context) => {
-			const encodedChange = change as unknown as EncodedModularChangeset;
+
+		decode: (encodedChange: EncodedModularChangeset, context) => {
+			const [fieldChanges, nodeChanges] = decodeFieldChangesFromJson(
+				encodedChange.changes,
+				context,
+				idAllocatorFromMaxId(encodedChange.maxId),
+			);
 			const decoded: Mutable<ModularChangeset> = {
-				fieldChanges: decodeFieldChangesFromJson(encodedChange.changes, context),
+				fieldChanges,
+				nodeChanges,
 			};
+
 			if (encodedChange.builds !== undefined) {
 				decoded.builds = decodeDetachedNodes(encodedChange.builds, context);
 			}
@@ -341,6 +435,7 @@ export function makeV0Codec(
 			}
 			return decoded;
 		},
-		encodedSchema: EncodedModularChangeset,
 	};
+
+	return withSchemaValidation(EncodedModularChangeset, modularChangeCodec, validator);
 }