@fluidframework/tree 2.61.0 → 2.62.0

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

@@ -9,9 +9,7 @@ import {
 	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
-	type IMultiFormatCodec,
 	makeCodecFamily,
-	withSchemaValidation,
 } from "../codec/index.js";
 import { makeVersionDispatchingCodec } from "../codec/index.js";
 import type {
@@ -20,19 +18,11 @@ import type {
 	RevisionTag,
 	SchemaAndPolicy,
 } from "../core/index.js";
-import {
-	type JsonCompatibleReadOnly,
-	JsonCompatibleReadOnlySchema,
-	mapIterable,
-} from "../util/index.js";
+import type { JsonCompatibleReadOnly } from "../util/index.js";
 
 import type { SummaryData } from "./editManager.js";
-import {
-	type Commit,
-	type EncodedCommit,
-	EncodedEditManager,
-	type SequencedCommit,
-} from "./editManagerFormat.js";
+import { makeV1CodecWithVersion } from "./editManagerCodecsV1toV4.js";
+import { makeV5CodecWithVersion } from "./editManagerCodecsV5.js";
 
 export interface EditManagerEncodingContext {
 	idCompressor: IIdCompressor;
@@ -74,156 +64,6 @@ export function makeEditManagerCodecs<TChangeset>(
 		[2, makeV1CodecWithVersion(changeCodecs.resolve(2), revisionTagCodec, options, 2)],
 		[3, makeV1CodecWithVersion(changeCodecs.resolve(3), revisionTagCodec, options, 3)],
 		[4, makeV1CodecWithVersion(changeCodecs.resolve(4), revisionTagCodec, options, 4)],
+		[5, makeV5CodecWithVersion(changeCodecs.resolve(4), revisionTagCodec, options, 5)],
 	]);
 }
-
-function makeV1CodecWithVersion<TChangeset>(
-	changeCodec: IMultiFormatCodec<
-		TChangeset,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-	options: ICodecOptions,
-	version: EncodedEditManager<TChangeset>["version"],
-): IJsonCodec<
-	SummaryData<TChangeset>,
-	JsonCompatibleReadOnly,
-	JsonCompatibleReadOnly,
-	EditManagerEncodingContext
-> {
-	const format = EncodedEditManager(
-		changeCodec.json.encodedSchema ?? JsonCompatibleReadOnlySchema,
-	);
-
-	const encodeCommit = <T extends Commit<TChangeset>>(
-		commit: T,
-		context: ChangeEncodingContext,
-		// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-	) => ({
-		...commit,
-		revision: revisionTagCodec.encode(commit.revision, {
-			originatorId: commit.sessionId,
-			idCompressor: context.idCompressor,
-			revision: undefined,
-		}),
-		change: changeCodec.json.encode(commit.change, { ...context, revision: commit.revision }),
-	});
-
-	const decodeCommit = <T extends EncodedCommit<JsonCompatibleReadOnly>>(
-		commit: T,
-		context: ChangeEncodingContext,
-		// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-	) => {
-		const revision = revisionTagCodec.decode(commit.revision, {
-			originatorId: commit.sessionId,
-			idCompressor: context.idCompressor,
-			revision: undefined,
-		});
-
-		return {
-			...commit,
-			revision,
-			change: changeCodec.json.decode(commit.change, { ...context, revision }),
-		};
-	};
-
-	const codec: IJsonCodec<
-		SummaryData<TChangeset>,
-		EncodedEditManager<TChangeset>,
-		EncodedEditManager<TChangeset>,
-		EditManagerEncodingContext
-	> = withSchemaValidation(
-		format,
-		{
-			encode: (data, context: EditManagerEncodingContext) => {
-				const json: EncodedEditManager<TChangeset> = {
-					trunk: data.trunk.map((commit) =>
-						encodeCommit(commit, {
-							originatorId: commit.sessionId,
-							idCompressor: context.idCompressor,
-							schema: context.schema,
-							revision: undefined,
-						}),
-					),
-					branches: Array.from(data.peerLocalBranches.entries(), ([sessionId, branch]) => [
-						sessionId,
-						{
-							base: revisionTagCodec.encode(branch.base, {
-								originatorId: sessionId,
-								idCompressor: context.idCompressor,
-								revision: undefined,
-							}),
-							commits: branch.commits.map((commit) =>
-								encodeCommit(commit, {
-									originatorId: commit.sessionId,
-									idCompressor: context.idCompressor,
-									schema: context.schema,
-									revision: undefined,
-								}),
-							),
-						},
-					]),
-					version,
-				};
-				return json;
-			},
-			decode: (
-				json: EncodedEditManager<TChangeset>,
-				context: EditManagerEncodingContext,
-			): SummaryData<TChangeset> => {
-				// TODO: sort out EncodedCommit vs Commit, and make this type check without `any`.
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				const trunk: readonly any[] = json.trunk;
-				return {
-					trunk: trunk.map(
-						(commit): SequencedCommit<TChangeset> =>
-							// TODO: sort out EncodedCommit vs Commit, and make this type check without `as`.
-							// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-							decodeCommit(commit, {
-								originatorId: commit.sessionId,
-								idCompressor: context.idCompressor,
-								revision: undefined,
-							}),
-					),
-					peerLocalBranches: new Map(
-						mapIterable(json.branches, ([sessionId, branch]) => [
-							sessionId,
-							{
-								base: revisionTagCodec.decode(branch.base, {
-									originatorId: sessionId,
-									idCompressor: context.idCompressor,
-									revision: undefined,
-								}),
-								commits: branch.commits.map((commit) =>
-									// TODO: sort out EncodedCommit vs Commit, and make this type check without `as`.
-									decodeCommit(commit as EncodedCommit<JsonCompatibleReadOnly>, {
-										originatorId: commit.sessionId,
-										idCompressor: context.idCompressor,
-										revision: undefined,
-									}),
-								),
-							},
-						]),
-					),
-				};
-			},
-		},
-		options.jsonValidator,
-	);
-	// TODO: makeVersionedValidatedCodec and withSchemaValidation should allow the codec to decode JsonCompatibleReadOnly, or Versioned or something like that,
-	// and not leak the internal encoded format in the API surface.
-	// Fixing that would remove the need for this cast.
-	return codec as unknown as IJsonCodec<
-		SummaryData<TChangeset>,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		EditManagerEncodingContext
-	>;
-}

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

@@ -0,0 +1,245 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import type { IJsonCodec, IMultiFormatCodec } from "../codec/index.js";
+import type {
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+	SchemaAndPolicy,
+} from "../core/index.js";
+import { mapIterable, type JsonCompatibleReadOnly, type Mutable } from "../util/index.js";
+import type {
+	Commit,
+	EncodedCommit,
+	EncodedSharedBranch,
+	SequencedCommit,
+} from "./editManagerFormatCommons.js";
+import type { SharedBranchSummaryData } from "./editManager.js";
+import { decodeBranchId, encodeBranchId } from "./branchIdCodec.js";
+
+export interface EditManagerEncodingContext {
+	idCompressor: IIdCompressor;
+	readonly schema?: SchemaAndPolicy;
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function encodeCommit<TChangeset, T extends Commit<TChangeset>>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	commit: T,
+	context: ChangeEncodingContext,
+) {
+	return {
+		...commit,
+		revision: revisionTagCodec.encode(commit.revision, {
+			originatorId: commit.sessionId,
+			idCompressor: context.idCompressor,
+			revision: undefined,
+		}),
+		change: changeCodec.json.encode(commit.change, { ...context, revision: commit.revision }),
+	};
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function decodeCommit<TChangeset, T extends EncodedCommit<JsonCompatibleReadOnly>>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	commit: T,
+	context: ChangeEncodingContext,
+) {
+	const revision = revisionTagCodec.decode(commit.revision, {
+		originatorId: commit.sessionId,
+		idCompressor: context.idCompressor,
+		revision: undefined,
+	});
+
+	return {
+		...commit,
+		revision,
+		change: changeCodec.json.decode(commit.change, { ...context, revision }),
+	};
+}
+
+export function encodeSharedBranch<TChangeset>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	data: SharedBranchSummaryData<TChangeset>,
+	context: EditManagerEncodingContext,
+	originatorId: SessionId | undefined,
+): EncodedSharedBranch<TChangeset> {
+	const json: Mutable<EncodedSharedBranch<TChangeset>> = {
+		trunk: data.trunk.map((commit) =>
+			encodeCommit(changeCodec, revisionTagCodec, commit, {
+				originatorId: commit.sessionId,
+				idCompressor: context.idCompressor,
+				schema: context.schema,
+				revision: undefined,
+			}),
+		),
+		peers: Array.from(data.peerLocalBranches.entries(), ([sessionId, branch]) => [
+			sessionId,
+			{
+				base: revisionTagCodec.encode(branch.base, {
+					originatorId: sessionId,
+					idCompressor: context.idCompressor,
+					revision: undefined,
+				}),
+				commits: branch.commits.map((commit) =>
+					encodeCommit(changeCodec, revisionTagCodec, commit, {
+						originatorId: commit.sessionId,
+						idCompressor: context.idCompressor,
+						schema: context.schema,
+						revision: undefined,
+					}),
+				),
+			},
+		]),
+	};
+	if (data.session !== undefined) {
+		json.session = data.session;
+	}
+	if (data.id !== undefined) {
+		json.id = encodeBranchId(context.idCompressor, data.id);
+	}
+	if (data.name !== undefined) {
+		json.name = data.name;
+	}
+	if (data.author !== undefined) {
+		json.author = data.author;
+	}
+	if (data.base !== undefined) {
+		assert(
+			originatorId !== undefined,
+			0xc62 /* Cannot encode branch base without originatorId */,
+		);
+		json.base = revisionTagCodec.encode(data.base, {
+			originatorId,
+			idCompressor: context.idCompressor,
+			revision: undefined,
+		});
+	}
+	return json;
+}
+
+export function decodeSharedBranch<TChangeset>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	json: EncodedSharedBranch<TChangeset>,
+	context: EditManagerEncodingContext,
+	originatorId: SessionId | undefined,
+): SharedBranchSummaryData<TChangeset> {
+	// TODO: sort out EncodedCommit vs Commit, and make this type check without `any`.
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const trunk: readonly any[] = json.trunk;
+	const data: Mutable<SharedBranchSummaryData<TChangeset>> = {
+		trunk: trunk.map(
+			(commit): SequencedCommit<TChangeset> =>
+				// TODO: sort out EncodedCommit vs Commit, and make this type check without `as`.
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+				decodeCommit(changeCodec, revisionTagCodec, commit, {
+					originatorId: commit.sessionId,
+					idCompressor: context.idCompressor,
+					revision: undefined,
+				}),
+		),
+		peerLocalBranches: new Map(
+			mapIterable(json.peers, ([sessionId, branch]) => [
+				sessionId,
+				{
+					base: revisionTagCodec.decode(branch.base, {
+						originatorId: sessionId,
+						idCompressor: context.idCompressor,
+						revision: undefined,
+					}),
+					commits: branch.commits.map((commit) =>
+						// TODO: sort out EncodedCommit vs Commit, and make this type check without `as`.
+						decodeCommit(
+							changeCodec,
+							revisionTagCodec,
+							commit as EncodedCommit<JsonCompatibleReadOnly>,
+							{
+								originatorId: commit.sessionId,
+								idCompressor: context.idCompressor,
+								revision: undefined,
+							},
+						),
+					),
+				},
+			]),
+		),
+	};
+	if (json.session !== undefined) {
+		data.session = json.session;
+	}
+	if (json.name !== undefined) {
+		data.name = json.name;
+	}
+	if (json.author !== undefined) {
+		data.author = json.author;
+	}
+	if (json.id !== undefined) {
+		assert(
+			originatorId !== undefined,
+			0xc63 /* Cannot decode branch id without originatorId */,
+		);
+		data.id = decodeBranchId(context.idCompressor, json.id, { originatorId });
+	}
+	if (json.base !== undefined) {
+		assert(
+			originatorId !== undefined,
+			0xc64 /* Cannot decode branch base without originatorId */,
+		);
+		data.base = revisionTagCodec.decode(json.base, {
+			originatorId,
+			idCompressor: context.idCompressor,
+			revision: undefined,
+		});
+	}
+	return data;
+}

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

@@ -0,0 +1,108 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+
+import {
+	type ICodecOptions,
+	type IJsonCodec,
+	type IMultiFormatCodec,
+	withSchemaValidation,
+} from "../codec/index.js";
+import type {
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+	SchemaAndPolicy,
+} from "../core/index.js";
+import { type JsonCompatibleReadOnly, JsonCompatibleReadOnlySchema } from "../util/index.js";
+
+import type { SummaryData } from "./editManager.js";
+import { EncodedEditManager } from "./editManagerFormatV1toV4.js";
+import { decodeSharedBranch, encodeSharedBranch } from "./editManagerCodecsCommons.js";
+
+export interface EditManagerEncodingContext {
+	idCompressor: IIdCompressor;
+	readonly schema?: SchemaAndPolicy;
+}
+
+export function makeV1CodecWithVersion<TChangeset>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	options: ICodecOptions,
+	version: EncodedEditManager<TChangeset>["version"],
+): IJsonCodec<
+	SummaryData<TChangeset>,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnly,
+	EditManagerEncodingContext
+> {
+	const format = EncodedEditManager(
+		changeCodec.json.encodedSchema ?? JsonCompatibleReadOnlySchema,
+	);
+
+	const codec: IJsonCodec<
+		SummaryData<TChangeset>,
+		EncodedEditManager<TChangeset>,
+		EncodedEditManager<TChangeset>,
+		EditManagerEncodingContext
+	> = withSchemaValidation(
+		format,
+		{
+			encode: (data, context: EditManagerEncodingContext) => {
+				const mainBranch = encodeSharedBranch(
+					changeCodec,
+					revisionTagCodec,
+					data.main,
+					context,
+					data.originator,
+				);
+				const json: EncodedEditManager<TChangeset> = {
+					trunk: mainBranch.trunk,
+					branches: mainBranch.peers,
+					version,
+				};
+				return json;
+			},
+			decode: (
+				json: EncodedEditManager<TChangeset>,
+				context: EditManagerEncodingContext,
+			): SummaryData<TChangeset> => {
+				return {
+					main: decodeSharedBranch(
+						changeCodec,
+						revisionTagCodec,
+						{
+							trunk: json.trunk,
+							peers: json.branches,
+						},
+						context,
+						undefined, // originatorId is not encoded in v1
+					),
+				};
+			},
+		},
+		options.jsonValidator,
+	);
+	// TODO: makeVersionedValidatedCodec and withSchemaValidation should allow the codec to decode JsonCompatibleReadOnly, or Versioned or something like that,
+	// and not leak the internal encoded format in the API surface.
+	// Fixing that would remove the need for this cast.
+	return codec as unknown as IJsonCodec<
+		SummaryData<TChangeset>,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		EditManagerEncodingContext
+	>;
+}

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

@@ -0,0 +1,156 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+
+import {
+	type ICodecOptions,
+	type IJsonCodec,
+	type IMultiFormatCodec,
+	withSchemaValidation,
+} from "../codec/index.js";
+import type {
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+	SchemaAndPolicy,
+} from "../core/index.js";
+import {
+	type JsonCompatibleReadOnly,
+	JsonCompatibleReadOnlySchema,
+	type Mutable,
+} from "../util/index.js";
+
+import type { SharedBranchSummaryData, SummaryData } from "./editManager.js";
+import { EncodedEditManager } from "./editManagerFormatV5.js";
+import { decodeSharedBranch, encodeSharedBranch } from "./editManagerCodecsCommons.js";
+import type { EncodedSharedBranch } from "./editManagerFormatCommons.js";
+import type { BranchId } from "./branch.js";
+
+export interface EditManagerEncodingContext {
+	idCompressor: IIdCompressor;
+	readonly schema?: SchemaAndPolicy;
+}
+
+export function makeV5CodecWithVersion<TChangeset>(
+	changeCodec: IMultiFormatCodec<
+		TChangeset,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		ChangeEncodingContext
+	>,
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+	options: ICodecOptions,
+	version: EncodedEditManager<TChangeset>["version"],
+): IJsonCodec<
+	SummaryData<TChangeset>,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnly,
+	EditManagerEncodingContext
+> {
+	const format = EncodedEditManager(
+		changeCodec.json.encodedSchema ?? JsonCompatibleReadOnlySchema,
+	);
+
+	const codec: IJsonCodec<
+		SummaryData<TChangeset>,
+		EncodedEditManager<TChangeset>,
+		EncodedEditManager<TChangeset>,
+		EditManagerEncodingContext
+	> = withSchemaValidation(
+		format,
+		{
+			encode: (data: SummaryData<TChangeset>, context: EditManagerEncodingContext) => {
+				const mainBranch = encodeSharedBranch(
+					changeCodec,
+					revisionTagCodec,
+					data.main,
+					context,
+					data.originator,
+				);
+				assert(
+					data.originator !== undefined,
+					0xc65 /* Cannot encode V5 summary without originator */,
+				);
+				const json: Mutable<EncodedEditManager<TChangeset>> = {
+					main: mainBranch,
+					originator: data.originator,
+					version,
+				};
+				if (data.branches !== undefined && data.branches.size > 0) {
+					const branches: EncodedSharedBranch<TChangeset>[] = [];
+					for (const [_, branch] of data.branches) {
+						branches.push(
+							encodeSharedBranch(
+								changeCodec,
+								revisionTagCodec,
+								branch,
+								context,
+								data.originator,
+							),
+						);
+					}
+					json.branches = branches;
+				}
+				return json;
+			},
+			decode: (
+				json: EncodedEditManager<TChangeset>,
+				context: EditManagerEncodingContext,
+			): SummaryData<TChangeset> => {
+				const mainBranch = decodeSharedBranch(
+					changeCodec,
+					revisionTagCodec,
+					json.main,
+					context,
+					json.originator,
+				);
+
+				const decoded: Mutable<SummaryData<TChangeset>> = {
+					main: mainBranch,
+					originator: json.originator,
+				};
+
+				if (json.branches !== undefined) {
+					const branches = new Map<BranchId, SharedBranchSummaryData<TChangeset>>();
+					for (const branch of json.branches) {
+						const decodedBranch = decodeSharedBranch(
+							changeCodec,
+							revisionTagCodec,
+							branch,
+							context,
+							json.originator,
+						);
+						assert(
+							decodedBranch.id !== undefined,
+							0xc66 /* Shared branches must have an id */,
+						);
+						assert(!branches.has(decodedBranch.id), 0xc67 /* Duplicate shared branch id */);
+						branches.set(decodedBranch.id, decodedBranch);
+					}
+
+					decoded.branches = branches;
+				}
+				return decoded;
+			},
+		},
+		options.jsonValidator,
+	);
+	// TODO: makeVersionedValidatedCodec and withSchemaValidation should allow the codec to decode JsonCompatibleReadOnly, or Versioned or something like that,
+	// and not leak the internal encoded format in the API surface.
+	// Fixing that would remove the need for this cast.
+	return codec as unknown as IJsonCodec<
+		SummaryData<TChangeset>,
+		JsonCompatibleReadOnly,
+		JsonCompatibleReadOnly,
+		EditManagerEncodingContext
+	>;
+}