@fluidframework/tree 2.51.0-347100 → 2.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/tree",
-  "version": "2.51.0-347100",
+  "version": "2.51.0",
   "description": "Distributed tree",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -101,17 +101,17 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "2.51.0-347100",
-    "@fluidframework/container-runtime": "2.51.0-347100",
-    "@fluidframework/core-interfaces": "2.51.0-347100",
-    "@fluidframework/core-utils": "2.51.0-347100",
-    "@fluidframework/datastore-definitions": "2.51.0-347100",
-    "@fluidframework/driver-definitions": "2.51.0-347100",
-    "@fluidframework/id-compressor": "2.51.0-347100",
-    "@fluidframework/runtime-definitions": "2.51.0-347100",
-    "@fluidframework/runtime-utils": "2.51.0-347100",
-    "@fluidframework/shared-object-base": "2.51.0-347100",
-    "@fluidframework/telemetry-utils": "2.51.0-347100",
+    "@fluid-internal/client-utils": "~2.51.0",
+    "@fluidframework/container-runtime": "~2.51.0",
+    "@fluidframework/core-interfaces": "~2.51.0",
+    "@fluidframework/core-utils": "~2.51.0",
+    "@fluidframework/datastore-definitions": "~2.51.0",
+    "@fluidframework/driver-definitions": "~2.51.0",
+    "@fluidframework/id-compressor": "~2.51.0",
+    "@fluidframework/runtime-definitions": "~2.51.0",
+    "@fluidframework/runtime-utils": "~2.51.0",
+    "@fluidframework/shared-object-base": "~2.51.0",
+    "@fluidframework/telemetry-utils": "~2.51.0",
     "@sinclair/typebox": "^0.34.13",
     "@tylerbu/sorted-btree-es6": "^1.8.0",
     "@types/ungap__structured-clone": "^1.2.0",
@@ -121,19 +121,19 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.1",
     "@biomejs/biome": "~1.9.3",
-    "@fluid-internal/mocha-test-setup": "2.51.0-347100",
-    "@fluid-private/stochastic-test-utils": "2.51.0-347100",
-    "@fluid-private/test-dds-utils": "2.51.0-347100",
-    "@fluid-private/test-drivers": "2.51.0-347100",
+    "@fluid-internal/mocha-test-setup": "~2.51.0",
+    "@fluid-private/stochastic-test-utils": "~2.51.0",
+    "@fluid-private/test-dds-utils": "~2.51.0",
+    "@fluid-private/test-drivers": "~2.51.0",
     "@fluid-tools/benchmark": "^0.51.0",
     "@fluid-tools/build-cli": "^0.56.0",
     "@fluidframework/build-common": "^2.0.3",
     "@fluidframework/build-tools": "^0.56.0",
-    "@fluidframework/container-definitions": "2.51.0-347100",
-    "@fluidframework/container-loader": "2.51.0-347100",
+    "@fluidframework/container-definitions": "~2.51.0",
+    "@fluidframework/container-loader": "~2.51.0",
     "@fluidframework/eslint-config-fluid": "^5.7.4",
-    "@fluidframework/test-runtime-utils": "2.51.0-347100",
-    "@fluidframework/test-utils": "2.51.0-347100",
+    "@fluidframework/test-runtime-utils": "~2.51.0",
+    "@fluidframework/test-utils": "~2.51.0",
     "@fluidframework/tree-previous": "npm:@fluidframework/tree@2.50.0",
     "@microsoft/api-extractor": "7.52.8",
     "@types/diff": "^3.5.1",

package/src/feature-libraries/index.ts

@@ -84,22 +84,7 @@ export {
 	type FieldChangeEncodingContext,
 	type FieldKindConfiguration,
 	type FieldKindConfigurationEntry,
-	getAllowedContentDiscrepancies,
-	isRepoSuperset,
-	type AllowedTypeDiscrepancy,
-	type FieldKindDiscrepancy,
-	type ValueSchemaDiscrepancy,
-	type FieldDiscrepancy,
-	type NodeDiscrepancy,
-	type NodeKindDiscrepancy,
-	type NodeFieldsDiscrepancy,
 	isNeverTree,
-	type LinearExtension,
-	type Realizer,
-	fieldRealizer,
-	PosetComparisonResult,
-	comparePosetElements,
-	posetLte,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";

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

@@ -22,10 +22,6 @@ import type { FullSchemaPolicy } from "./fieldKind.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { isNeverTree } from "./isNeverTree.js";
 
-// TODO:
-// The comparisons in this file seem redundant with those in discrepancies.ts.
-// Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
-
 /**
  * @returns true iff `superset` is a superset of `original`.
  *

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

@@ -77,20 +77,3 @@ export type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
-export {
-	getAllowedContentDiscrepancies,
-	isRepoSuperset,
-	type AllowedTypeDiscrepancy,
-	type FieldKindDiscrepancy,
-	type ValueSchemaDiscrepancy,
-	type FieldDiscrepancy,
-	type NodeDiscrepancy,
-	type NodeKindDiscrepancy,
-	type NodeFieldsDiscrepancy,
-	type LinearExtension,
-	type Realizer,
-	fieldRealizer,
-	PosetComparisonResult,
-	comparePosetElements,
-	posetLte,
-} from "./discrepancies.js";

package/src/packageVersion.ts

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

package/src/shared-tree/schematizeTree.ts

@@ -19,7 +19,7 @@ import {
 	defaultSchemaPolicy,
 	mapTreeFromCursor,
 } from "../feature-libraries/index.js";
-import type { SchemaCompatibilityTester } from "../simple-tree/index.js";
+import { toStoredSchema, type SchemaCompatibilityTester } from "../simple-tree/index.js";
 import { isReadonlyArray } from "../util/index.js";
 
 import type { ITreeCheckout } from "./treeCheckout.js";
@@ -75,7 +75,7 @@ export function initializeContent(
 
 	assert(
 		allowsRepoSuperset(defaultSchemaPolicy, newSchema, incrementalSchemaUpdate),
-		0x5c9 /* Incremental Schema during update should be a allow a superset of the final schema */,
+		0x5c9 /* Incremental Schema during update should allow a superset of the final schema */,
 	);
 	// Update to intermediate schema
 	schemaRepository.updateSchema(incrementalSchemaUpdate);
@@ -219,7 +219,7 @@ export function ensureSchema(
 			return false;
 		}
 		case UpdateType.SchemaCompatible: {
-			checkout.updateSchema(viewSchema.viewSchemaAsStored);
+			checkout.updateSchema(toStoredSchema(viewSchema.viewSchemaRoot));
 			return true;
 		}
 		default: {

package/src/shared-tree/schematizingTreeView.ts

@@ -52,6 +52,7 @@ import {
 	createUnknownOptionalFieldPolicy,
 	prepareForInsertionContextless,
 	type FieldSchema,
+	toStoredSchema,
 	tryDisposeTreeNode,
 } from "../simple-tree/index.js";
 import {
@@ -137,11 +138,7 @@ export class SchematizingSimpleTreeView<
 			allowUnknownOptionalFields: createUnknownOptionalFieldPolicy(this.rootFieldSchema),
 		};
 
-		this.viewSchema = new SchemaCompatibilityTester(
-			this.schemaPolicy,
-			{},
-			this.rootFieldSchema,
-		);
+		this.viewSchema = new SchemaCompatibilityTester(this.schemaPolicy, this.rootFieldSchema);
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -178,7 +175,7 @@ export class SchematizingSimpleTreeView<
 		}
 
 		this.runSchemaEdit(() => {
-			const schema = this.viewSchema.viewSchemaAsStored;
+			const schema = toStoredSchema(this.viewSchema.viewSchemaRoot);
 			const mapTree = prepareForInsertionContextless(
 				content as InsertableContent | undefined,
 				this.rootFieldSchema,

package/src/shared-tree/tree.ts

@@ -450,7 +450,7 @@ export function runTransaction<
 				"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.",
 			);
 		}
-		assert(context instanceof Context, "Expected context to be a Context instance.");
+		assert(context instanceof Context, 0xbe3 /* Expected context to be a Context instance. */);
 		return runTransactionInCheckout(context.checkout, () => t(node), preconditions);
 	}
 }

package/src/shared-tree/treeCheckout.ts

@@ -788,7 +788,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 		if (allowNonSupersetSchema !== true) {
 			assert(
 				allowsRepoSuperset(defaultSchemaPolicy, this.storedSchema.clone(), newSchema),
-				"New schema must allow all documents allowed by old schema",
+				0xbe6 /* New schema must allow all documents allowed by old schema */,
 			);
 		}
 		this.editor.schema.setStoredSchema(this.storedSchema.clone(), newSchema);

package/src/simple-tree/api/schemaCompatibilityTester.ts

@@ -3,30 +3,26 @@
  * Licensed under the MIT License.
  */
 
-import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 
+import type { TreeStoredSchema } from "../../core/index.js";
 import {
-	AdaptedViewSchema,
-	type TreeNodeStoredSchema,
-	type Adapters,
-	type TreeFieldStoredSchema,
-	type TreeNodeSchemaIdentifier,
-	type TreeStoredSchema,
-} from "../../core/index.js";
-import {
+	allowsRepoSuperset,
 	FieldKinds,
 	type FullSchemaPolicy,
-	type FieldDiscrepancy,
-	getAllowedContentDiscrepancies,
 	isNeverTree,
-	PosetComparisonResult,
-	fieldRealizer,
-	comparePosetElements,
 } from "../../feature-libraries/index.js";
 import type { FieldSchema } from "../fieldSchema.js";
-import { toStoredSchema } from "../toStoredSchema.js";
 
 import type { SchemaCompatibilityStatus } from "./tree.js";
+import {
+	comparePosetElements,
+	fieldRealizer,
+	getAllowedContentDiscrepancies,
+	PosetComparisonResult,
+	type FieldDiscrepancy,
+} from "../discrepancies.js";
+import { toStoredSchema } from "../toStoredSchema.js";
 
 /**
  * A collection of View information for schema, including policy.
@@ -34,21 +30,13 @@ import type { SchemaCompatibilityStatus } from "./tree.js";
  * This contains everything needed to determine compatibility with a given stored schema.
  */
 export class SchemaCompatibilityTester {
-	/**
-	 * Cached conversion of the view schema in the stored schema format.
-	 */
-	public readonly viewSchemaAsStored: TreeStoredSchema;
-
 	/**
 	 * @param viewSchemaRoot - Schema for the root field.
 	 */
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
-		public readonly adapters: Adapters,
-		viewSchemaRoot: FieldSchema,
-	) {
-		this.viewSchemaAsStored = toStoredSchema(viewSchemaRoot);
-	}
+		public readonly viewSchemaRoot: FieldSchema,
+	) {}
 
 	/**
 	 * Determines the compatibility of a stored document
@@ -63,9 +51,6 @@ export class SchemaCompatibilityTester {
 	public checkCompatibility(
 		stored: TreeStoredSchema,
 	): Omit<SchemaCompatibilityStatus, "canInitialize"> {
-		// TODO: support adapters
-		// const adapted = this.adaptRepo(stored);
-
 		// View schema allows a subset of documents that stored schema does, and the discrepancies are allowed by policy
 		// determined by the view schema (i.e. objects with extra optional fields in the stored schema have opted into allowing this.
 		// In the future, this would also include things like:
@@ -92,16 +77,7 @@ export class SchemaCompatibilityTester {
 						canView = false;
 					}
 
-					if (
-						discrepancy.view.some(
-							(identifier) =>
-								!isNeverTree(
-									this.policy,
-									this.viewSchemaAsStored,
-									this.viewSchemaAsStored.nodeSchema.get(identifier),
-								),
-						)
-					) {
+					if (discrepancy.view.length > 0) {
 						// View schema has extra allowed types that the stored schema does not.
 						canView = false;
 					}
@@ -151,32 +127,24 @@ export class SchemaCompatibilityTester {
 			}
 		};
 
-		for (const discrepancy of getAllowedContentDiscrepancies(
-			this.viewSchemaAsStored,
-			stored,
-		)) {
+		for (const discrepancy of getAllowedContentDiscrepancies(this.viewSchemaRoot, stored)) {
 			if (!canView && !canUpgrade) {
 				break;
 			}
 
 			switch (discrepancy.mismatch) {
 				case "nodeKind": {
-					const viewNodeSchema = this.viewSchemaAsStored.nodeSchema.get(
-						discrepancy.identifier,
-					);
 					const storedNodeSchema = stored.nodeSchema.get(discrepancy.identifier);
 					// We conservatively do not allow node types to change.
 					// The only time this might be valid in the sense that the data canonically converts is converting an object node
 					// to a map node over the union of all the object fields' types.
 					if (discrepancy.stored === undefined) {
-						const viewIsNever =
-							viewNodeSchema !== undefined
-								? isNeverTree(this.policy, this.viewSchemaAsStored, viewNodeSchema)
-								: true;
-						if (!viewIsNever) {
-							// View schema has added a node type that the stored schema doesn't know about.
-							canView = false;
-						}
+						// View schema has added a node type that the stored schema doesn't know about.
+						// Note that all cases which trigger this should also trigger an AllowedTypeDiscrepancy (where the type is used).
+						// This means this case should be redundant and could be removed in the future if there is a reason to do so
+						// (like simplifying enablable type support).
+						// See the TODO in getAllowedContentDiscrepancies.
+						canView = false;
 					} else if (discrepancy.view === undefined) {
 						const storedIsNever =
 							storedNodeSchema !== undefined
@@ -184,22 +152,18 @@ export class SchemaCompatibilityTester {
 								: true;
 						if (!storedIsNever) {
 							// Stored schema has a node type that the view schema doesn't know about.
+							// The design of allowUnknownOptionalFields allows adding new optional content to types,
+							// and the new optional content can use new types.
+							// Therefore this case needs to be supported for viewing.
+							// However, it is not supported for upgrade as the stored document must be newer (or at least more general) than the view in this case.
+							// The fact that there might be removed trees with a root of this type which only appears in the stored schema is why this must set canUpgrade to false.
 							canUpgrade = false;
 						}
 					} else {
-						// Node type exists in both schemas but has changed. We conservatively never allow this.
-						const storedIsNever =
-							storedNodeSchema !== undefined
-								? isNeverTree(this.policy, stored, storedNodeSchema)
-								: true;
-						const viewIsNever =
-							viewNodeSchema !== undefined
-								? isNeverTree(this.policy, this.viewSchemaAsStored, viewNodeSchema)
-								: true;
-						if (!storedIsNever || !viewIsNever) {
-							canView = false;
-							canUpgrade = false;
-						}
+						// Node type exists in both schemas but kind has changed. We conservatively never allow this.
+						// See note above about cases where this could be allowed if needed.
+						canView = false;
+						canUpgrade = false;
 					}
 					break;
 				}
@@ -217,71 +181,17 @@ export class SchemaCompatibilityTester {
 			}
 		}
 
+		if (canUpgrade) {
+			assert(
+				allowsRepoSuperset(this.policy, stored, toStoredSchema(this.viewSchemaRoot)),
+				0xbf2 /* View schema must be a superset of the stored schema to allow upgrade */,
+			);
+		}
+
 		return {
 			canView,
 			canUpgrade,
 			isEquivalent: canView && canUpgrade,
 		};
 	}
-
-	/**
-	 * Compute a schema that `original` could be viewed as using adapters as needed.
-	 *
-	 * TODO: have a way for callers to get invalidated on schema updates.
-	 */
-	public adaptRepo(stored: TreeStoredSchema): AdaptedViewSchema {
-		// Sanity check on adapters:
-		// it's probably a bug if they use the never types,
-		// since there never is a reason to have a never type as an adapter input,
-		// and its impossible for an adapter to be correctly implemented if its output type is never
-		// (unless its input is also never).
-
-		for (const adapter of this.adapters?.tree ?? []) {
-			if (
-				isNeverTree(
-					this.policy,
-					this.viewSchemaAsStored,
-					this.viewSchemaAsStored.nodeSchema.get(adapter.output),
-				)
-			) {
-				fail(0xb3d /* tree adapter for stored adapter.output should not be never */);
-			}
-		}
-
-		const adapted = {
-			rootFieldSchema: this.adaptField(stored.rootFieldSchema),
-			nodeSchema: new Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>(),
-		};
-
-		for (const [key, schema] of stored.nodeSchema) {
-			const adapatedTree = this.adaptTree(schema);
-			adapted.nodeSchema.set(key, adapatedTree);
-		}
-
-		// TODO: subset these adapters to the ones that were needed/used.
-		return new AdaptedViewSchema(this.adapters, adapted);
-	}
-
-	/**
-	 * Adapt original such that it allows member types which can be adapted to its specified types.
-	 */
-	private adaptField(original: TreeFieldStoredSchema): TreeFieldStoredSchema {
-		if (original.types !== undefined) {
-			const types: Set<TreeNodeSchemaIdentifier> = new Set(original.types);
-			for (const treeAdapter of this.adapters?.tree ?? []) {
-				if (types.has(treeAdapter.input)) {
-					types.delete(treeAdapter.input);
-					types.add(treeAdapter.output);
-				}
-			}
-
-			return { kind: original.kind, types, persistedMetadata: undefined };
-		}
-		return original;
-	}
-
-	private adaptTree(original: TreeNodeStoredSchema): TreeNodeStoredSchema {
-		// TODO: support adapters like missing field adapters.
-		return original;
-	}
 }

package/src/simple-tree/api/schemaCreationUtilities.ts

@@ -197,10 +197,13 @@ export function enumEntries(
 		}
 		// At this point, it is expected that all remaining cases are reverse mappings,
 		// but do some asserts to ensure that the above logic is sufficient.
-		assert(typeof value === "string", "expected reverse mapping and thus a string value");
+		assert(
+			typeof value === "string",
+			0xbe4 /* expected reverse mapping and thus a string value */,
+		);
 		assert(
 			Number.parseFloat(key).toString() === key,
-			"expected reverse mapping and thus a key that is a normalized number",
+			0xbe5 /* expected reverse mapping and thus a key that is a normalized number */,
 		);
 		// Discard the reverse mapping.
 		return false;

package/src/simple-tree/api/storedSchema.ts

@@ -103,7 +103,6 @@ export function comparePersistedSchema(
 	const stored = schemaCodec.decode(persisted as FormatV1);
 	const viewSchema = new SchemaCompatibilityTester(
 		defaultSchemaPolicy,
-		{},
 		normalizeFieldSchema(view),
 	);
 	return viewSchema.checkCompatibility(stored);