@fluidframework/tree 2.70.0 → 2.72.0

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

@@ -0,0 +1,360 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { objectToMap, type JsonCompatibleReadOnly } from "../../util/index.js";
+import { unreachableCase, transformMapValues } from "@fluidframework/core-utils/internal";
+import type {
+	SimpleAllowedTypeAttributes,
+	SimpleArrayNodeSchema,
+	SimpleFieldSchema,
+	SimpleLeafNodeSchema,
+	SimpleMapNodeSchema,
+	SimpleNodeSchema,
+	SimpleObjectFieldSchema,
+	SimpleObjectNodeSchema,
+	SimpleRecordNodeSchema,
+	SimpleTreeSchema,
+} from "../simpleSchema.js";
+import { NodeKind } from "../core/index.js";
+import type { FieldKind } from "../fieldSchema.js";
+import type { ValueSchema } from "../../core/index.js";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import * as Format from "../simpleSchemaFormatV1.js";
+import {
+	DiscriminatedUnionDispatcher,
+	extractJsonValidator,
+	FormatValidatorNoOp,
+	type FormatValidator,
+} from "../../codec/index.js";
+
+/**
+ * Encodes a simple schema (view or stored) into a serializable format.
+ * @remarks The JSON-compatible schema returned from this method is only intended for use in snapshots/comparisons of schemas.
+ * It is not possible to reconstruct a full schema (including metadata and persistedMetadata) from the encoded format.
+ * @param treeSchema - The tree schema to convert.
+ * @returns A serializable representation of the schema.
+ *
+ * @alpha
+ */
+export function encodeSimpleSchema(simpleSchema: SimpleTreeSchema): JsonCompatibleReadOnly {
+	// Convert types to serializable forms
+	const encodedDefinitions: Format.SimpleSchemaDefinitionsFormat = {};
+
+	for (const [identifier, schema] of simpleSchema.definitions) {
+		const encodedDefinition = encodeNodeSchema(schema);
+		encodedDefinitions[identifier] = encodedDefinition;
+	}
+
+	const encodedSchema: Format.SimpleTreeSchemaFormat = {
+		version: Format.SimpleSchemaFormatVersion.v1,
+		root: encodeField(simpleSchema.root),
+		definitions: encodedDefinitions,
+	};
+
+	return encodedSchema;
+}
+
+/**
+ * Decodes a JSON-compatible schema into a simple schema.
+ * @param encodedSchema - The encoded schema to decode.
+ * @param validator - The format validator to use to validate the encoded schema.
+ * @returns A decoded simple schema.
+ * @throws Will throw a usage error if the encoded schema is not in the expected format.
+ *
+ * @alpha
+ */
+export function decodeSimpleSchema(
+	encodedSchema: JsonCompatibleReadOnly,
+	validator?: FormatValidator,
+): SimpleTreeSchema {
+	const effectiveValidator = validator ?? FormatValidatorNoOp;
+	const compiledValidator = extractJsonValidator(effectiveValidator).compile(
+		Format.SimpleTreeSchemaFormat,
+	);
+	if (!compiledValidator.check(encodedSchema)) {
+		throw new UsageError(
+			"The provided simple schema is not valid according to the schema format.",
+		);
+	}
+
+	return {
+		root: decodeSimpleFieldSchema(encodedSchema.root),
+		definitions: new Map(
+			transformMapValues(objectToMap(encodedSchema.definitions), (value, key) => {
+				return decodeNodeSchema(value);
+			}),
+		),
+	};
+}
+
+/**
+ * Encodes a node schema to a serializable object.
+ * @param schema - The node schema to convert.
+ * @returns A serializable representation of the node schema.
+ */
+function encodeNodeSchema(schema: SimpleNodeSchema): Format.SimpleNodeSchemaUnionFormat {
+	const kind = schema.kind;
+	switch (kind) {
+		case NodeKind.Leaf:
+			return { leaf: encodeLeafNode(schema) };
+		case NodeKind.Array:
+			return { array: encodeContainerNode(schema) };
+		case NodeKind.Map:
+			return { map: encodeContainerNode(schema) };
+		case NodeKind.Record:
+			return { record: encodeContainerNode(schema) };
+		case NodeKind.Object:
+			return { object: encodeObjectNode(schema) };
+		default: {
+			unreachableCase(kind);
+		}
+	}
+}
+
+/**
+ * Encodes a leaf node schema to a serializable object.
+ * @param schema - The leaf node schema to convert.
+ * @returns A serializable representation of the leaf node schema.
+ */
+function encodeLeafNode(schema: SimpleLeafNodeSchema): Format.SimpleLeafNodeSchemaFormat {
+	return {
+		kind: schema.kind,
+		leafKind: schema.leafKind,
+	};
+}
+
+/**
+ * Encodes a container node schema (a simple schema that is a Map, Array, or Record) to a serializable object.
+ * @param schema - The container node schema to convert.
+ * @returns A serializable representation of the container node schema. Includes the `kind` for disambiguation between different
+ * container kinds.
+ */
+function encodeContainerNode(
+	schema: SimpleArrayNodeSchema | SimpleMapNodeSchema | SimpleRecordNodeSchema,
+):
+	| Format.SimpleArrayNodeSchemaFormat
+	| Format.SimpleMapNodeSchemaFormat
+	| Format.SimpleRecordNodeSchemaFormat {
+	return {
+		kind: schema.kind,
+		simpleAllowedTypes: encodeSimpleAllowedTypes(schema.simpleAllowedTypes),
+	};
+}
+
+/**
+ * Encodes a simple allowed types map to a serializable object. Needed because JSON serialization does not support Maps.
+ * @param simpleAllowedTypes - The simple allowed types map to convert.
+ * @returns A serializable representation of the simple allowed types.
+ */
+function encodeSimpleAllowedTypes(
+	simpleAllowedTypes: ReadonlyMap<string, SimpleAllowedTypeAttributes>,
+): Format.SimpleAllowedTypesFormat {
+	const encodedAllowedTypes: Format.SimpleAllowedTypesFormat = {};
+	for (const [identifier, attributes] of simpleAllowedTypes) {
+		encodedAllowedTypes[identifier] = {
+			isStaged: attributes.isStaged,
+		};
+	}
+	return encodedAllowedTypes;
+}
+
+/**
+ * Encodes an object node schema to a serializable object.
+ * @param schema - The object node schema to convert.
+ * @returns A serializable representation of the object node schema.
+ */
+function encodeObjectNode(
+	schema: SimpleObjectNodeSchema,
+): Format.SimpleObjectNodeSchemaFormat {
+	const encodedFields: Format.SimpleObjectFieldSchemasFormat = {};
+	for (const [fieldKey, fieldSchema] of schema.fields) {
+		encodedFields[fieldKey] = encodeObjectField(fieldSchema);
+	}
+
+	return {
+		kind: schema.kind,
+		fields: encodedFields,
+		allowUnknownOptionalFields: schema.allowUnknownOptionalFields,
+	};
+}
+
+/**
+ * Encodes an object field schema to a serializable object.
+ * @param fieldSchema - The object field schema to convert.
+ * @returns A serializable representation of the object field schema.
+ */
+function encodeObjectField(
+	fieldSchema: SimpleObjectFieldSchema,
+): Format.SimpleObjectFieldSchemaFormat {
+	const encodedField = encodeField(fieldSchema);
+	return { ...encodedField, storedKey: fieldSchema.storedKey };
+}
+
+/**
+ * Encodes a field schema to a serializable object.
+ * @param fieldSchema - The field schema to convert.
+ * @returns A serializable representation of the field schema.
+ */
+function encodeField(fieldSchema: SimpleFieldSchema): Format.SimpleFieldSchemaFormat {
+	return {
+		kind: fieldSchema.kind,
+		simpleAllowedTypes: encodeSimpleAllowedTypes(fieldSchema.simpleAllowedTypes),
+	};
+}
+
+const decodeNodeSchemaDispatcher: DiscriminatedUnionDispatcher<
+	Format.SimpleNodeSchemaUnionFormat,
+	[],
+	| SimpleLeafNodeSchema
+	| SimpleArrayNodeSchema
+	| SimpleMapNodeSchema
+	| SimpleRecordNodeSchema
+	| SimpleObjectNodeSchema
+> = new DiscriminatedUnionDispatcher({
+	leaf: decodeLeafNode,
+	array: decodeContainerNode,
+	map: decodeContainerNode,
+	record: decodeContainerNode,
+	object: decodeObjectNode,
+});
+
+/**
+ * Decodes a node schema from a JSON-compatible object.
+ * @param encodedNodeSchema - The encoded node schema to decode.
+ * @returns The decoded node schema.
+ */
+function decodeNodeSchema(
+	encodedNodeSchema: Format.SimpleNodeSchemaUnionFormat,
+):
+	| SimpleLeafNodeSchema
+	| SimpleArrayNodeSchema
+	| SimpleMapNodeSchema
+	| SimpleRecordNodeSchema
+	| SimpleObjectNodeSchema {
+	return decodeNodeSchemaDispatcher.dispatch(encodedNodeSchema);
+}
+
+/**
+ * Decodes a container node schema (array, map, record) from a JSON-compatible object.
+ * @param encodedContainerSchema - The encoded schema to decode.
+ * @returns The decoded container node schema.
+ */
+function decodeContainerNode(
+	encodedContainerSchema:
+		| Format.SimpleArrayNodeSchemaFormat
+		| Format.SimpleMapNodeSchemaFormat
+		| Format.SimpleRecordNodeSchemaFormat,
+): SimpleArrayNodeSchema | SimpleMapNodeSchema | SimpleRecordNodeSchema {
+	return {
+		kind: encodedContainerSchema.kind as NodeKind.Array | NodeKind.Map | NodeKind.Record,
+		simpleAllowedTypes: decodeSimpleAllowedTypes(encodedContainerSchema.simpleAllowedTypes),
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a leaf node schema from a JSON-compatible object.
+ * @param encodedLeafSchema - The encoded leaf node schema.
+ * @returns The decoded leaf node schema.
+ */
+function decodeLeafNode(
+	encodedLeafSchema: Format.SimpleLeafNodeSchemaFormat,
+): SimpleLeafNodeSchema {
+	return {
+		kind: NodeKind.Leaf,
+		leafKind: encodedLeafSchema.leafKind as ValueSchema,
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a object node schema from a JSON-compatible object.
+ * @param encodedObjectSchema - The encoded object node schema.
+ * @returns The decoded object node schema.
+ */
+function decodeObjectNode(
+	encodedObjectSchema: Format.SimpleObjectNodeSchemaFormat,
+): SimpleObjectNodeSchema {
+	return {
+		kind: NodeKind.Object,
+		fields: decodeObjectFields(encodedObjectSchema.fields),
+		// It is possible for allowUnknownOptionalFields to be undefined. This happens when serializing a Simple Schema derived
+		// from a stored schema.
+		allowUnknownOptionalFields: encodedObjectSchema.allowUnknownOptionalFields,
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values when decoding.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a map of object fields from a JSON-compatible object.
+ * @param encodedFields - The encoded fields.
+ * @returns A map of the decoded object fields.
+ */
+function decodeObjectFields(
+	encodedFields: Format.SimpleObjectFieldSchemasFormat,
+): ReadonlyMap<string, SimpleObjectFieldSchema> {
+	const fields = new Map<string, SimpleObjectFieldSchema>();
+	for (const [fieldKey, fieldSchema] of Object.entries(encodedFields)) {
+		fields.set(fieldKey, decodeObjectField(fieldSchema));
+	}
+	return fields;
+}
+
+/**
+ * Decodes a {@link SimpleObjectFieldSchema} from a JSON-compatible object.
+ * @param encodedField - The encoded field schema.
+ * @returns The decoded simple object field schema.
+ */
+function decodeObjectField(
+	encodedField: Format.SimpleObjectFieldSchemaFormat,
+): SimpleObjectFieldSchema {
+	const baseField = decodeSimpleFieldSchema(encodedField);
+	return {
+		...baseField,
+		storedKey: encodedField.storedKey,
+	};
+}
+
+/**
+ * Decodes a {@link SimpleFieldSchema} from a JSON-compatible object.
+ * @param encodedField - The encoded field schema.
+ * @returns The decoded simple field schema.
+ */
+function decodeSimpleFieldSchema(
+	encodedField: Format.SimpleFieldSchemaFormat,
+): SimpleFieldSchema {
+	return {
+		kind: encodedField.kind as FieldKind,
+		simpleAllowedTypes: decodeSimpleAllowedTypes(encodedField.simpleAllowedTypes),
+		// We cannot encode persistedMetadata or metadata, so we explicitly set them to empty values when decoding.
+		persistedMetadata: undefined,
+		metadata: {},
+	};
+}
+
+/**
+ * Decodes a simple allowed types map from a JSON-compatible object.
+ * @param encodedAllowedTypes - The encoded simple allowed types.
+ * @returns A map of the decoded simple allowed types.
+ */
+function decodeSimpleAllowedTypes(
+	encodedAllowedTypes: Format.SimpleAllowedTypesFormat,
+): ReadonlyMap<string, SimpleAllowedTypeAttributes> {
+	const untypedMap = objectToMap(encodedAllowedTypes);
+
+	const simpleAllowedTypes = transformMapValues(untypedMap, (value) => {
+		return {
+			isStaged: value.isStaged,
+		} satisfies SimpleAllowedTypeAttributes;
+	});
+
+	return simpleAllowedTypes;
+}

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

@@ -107,7 +107,10 @@ function convertNodeSchema(
 
 function convertArrayNodeSchema(schema: SimpleArrayNodeSchema): JsonArrayNodeSchema {
 	const allowedTypes: JsonSchemaRef[] = [];
-	schema.allowedTypesIdentifiers.forEach((type) => {
+	const allowedTypesIdentifiers: ReadonlySet<string> = new Set(
+		schema.simpleAllowedTypes.keys(),
+	);
+	allowedTypesIdentifiers.forEach((type) => {
 		allowedTypes.push(createSchemaRef(type));
 	});
 
@@ -206,7 +209,10 @@ function convertRecordLikeNodeSchema(
 	schema: SimpleRecordNodeSchema | SimpleMapNodeSchema,
 ): JsonMapNodeSchema | JsonRecordNodeSchema {
 	const allowedTypes: JsonSchemaRef[] = [];
-	schema.allowedTypesIdentifiers.forEach((type) => {
+	const allowedTypesIdentifiers: ReadonlySet<string> = new Set(
+		schema.simpleAllowedTypes.keys(),
+	);
+	allowedTypesIdentifiers.forEach((type) => {
 		allowedTypes.push(createSchemaRef(type));
 	});
 

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

@@ -4,15 +4,15 @@
  */
 
 import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
-import type { ICodecOptions } from "../../codec/index.js";
-import { SchemaVersion } from "../../core/index.js";
+import { FluidClientVersion, type ICodecOptions } from "../../codec/index.js";
+import { SchemaFormatVersion } from "../../core/index.js";
 import { encodeTreeSchema, makeSchemaCodec } from "../../feature-libraries/index.js";
 import {
 	clientVersionToSchemaVersion,
 	type FormatV1,
-	// eslint-disable-next-line import/no-internal-modules
+	// eslint-disable-next-line import-x/no-internal-modules
 } from "../../feature-libraries/schema-index/index.js";
-import type { JsonCompatible } from "../../util/index.js";
+import { brand, type JsonCompatible } from "../../util/index.js";
 import type { SchemaUpgrade } from "../core/index.js";
 import { normalizeFieldSchema, type ImplicitFieldSchema } from "../fieldSchema.js";
 import { toStoredSchema } from "../toStoredSchema.js";
@@ -100,7 +100,10 @@ export function comparePersistedSchema(
 ): Omit<SchemaCompatibilityStatus, "canInitialize"> {
 	// Any version can be passed down to makeSchemaCodec here.
 	// We only use the decode part, which always dispatches to the correct codec based on the version in the data, not the version passed to `makeSchemaCodec`.
-	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
+	const schemaCodec = makeSchemaCodec(
+		{ ...options, minVersionForCollab: FluidClientVersion.v2_0 },
+		brand(SchemaFormatVersion.v1),
+	);
 	const stored = schemaCodec.decode(persisted as FormatV1);
 	const config = new TreeViewConfigurationAlpha({
 		schema: normalizeFieldSchema(view),

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

@@ -431,7 +431,7 @@ export interface SchemaCompatibilityStatus {
 	 *
 	 * Note that other content in the stored schema that does not impact document compatibility, like {@link NodeSchemaOptionsAlpha.persistedMetadata}, does not affect this field.
 	 *
-	 * For the computation of this equivalence, {@link SchemaStaticsAlpha.staged | staged} schemas are not included.
+	 * For the computation of this equivalence, {@link SchemaStaticsBeta.staged | staged} schemas are not included.
 	 * If there are any unknown optional fields, even if allowed by {@link ObjectSchemaOptions.allowUnknownOptionalFields}, `isEquivalent` will be false.
 	 */
 	readonly isEquivalent: boolean;
@@ -445,7 +445,7 @@ export interface SchemaCompatibilityStatus {
 	 *
 	 * - An object node with {@link ObjectSchemaOptions.allowUnknownOptionalFields} to set to true that has additional optional fields in the stored schema beyond those mentioned in its view schema.
 	 *
-	 * - An additional type allowed at a location in the stored schema where it is {@link SchemaStaticsAlpha.staged | staged} in the view schema.
+	 * - An additional type allowed at a location in the stored schema where it is {@link SchemaStaticsBeta.staged | staged} in the view schema.
 	 *
 	 * In these cases `canUpgrade` and `isEquivalent` will be false.
 	 *

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

@@ -551,7 +551,7 @@ export interface TreeRecordNodeUnsafe<
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
  * @sealed
- * @alpha
+ * @beta
  * @system
  */
 export type UnannotateAllowedTypeUnsafe<
@@ -564,7 +564,7 @@ export type UnannotateAllowedTypeUnsafe<
  * {@link Unenforced} version of {@link AnnotatedAllowedType}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSchema>>>
 	extends AnnotatedAllowedType<T> {}
@@ -573,7 +573,7 @@ export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSche
  * {@link Unenforced} version of {@link AnnotatedAllowedTypes}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export interface AnnotatedAllowedTypesUnsafe
 	extends AnnotatedAllowedTypes<LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>> {}
@@ -592,7 +592,7 @@ export type AllowedTypesFullUnsafe<
  * {@link Unenforced} version of {@link AllowedTypesFullFromMixed}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type AllowedTypesFullFromMixedUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
@@ -603,7 +603,7 @@ export type AllowedTypesFullFromMixedUnsafe<
  * {@link Unenforced} version of {@link UnannotateAllowedTypesList}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type UnannotateAllowedTypesListUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],
@@ -615,7 +615,7 @@ export type UnannotateAllowedTypesListUnsafe<
  * {@link Unenforced} version of {@link AnnotateAllowedTypesList}.
  * @remarks
  * Do not use this type directly: it's only needed in the implementation of generic logic which define recursive schema, not when using recursive schema.
- * @system @sealed @alpha
+ * @system @sealed @beta
  */
 export type AnnotateAllowedTypesListUnsafe<
 	T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[],

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

@@ -67,7 +67,7 @@ export function toSimpleTreeSchema(
 	return {
 		root: copySchemaObjects
 			? ({
-					allowedTypesIdentifiers: normalizedSchema.allowedTypesIdentifiers,
+					simpleAllowedTypes: normalizedSchema.simpleAllowedTypes,
 					kind: normalizedSchema.kind,
 					metadata: normalizedSchema.metadata,
 					persistedMetadata: normalizedSchema.persistedMetadata,
@@ -82,7 +82,7 @@ export function toSimpleTreeSchema(
  *
  * @remarks Caches the result on the input schema for future calls.
  */
-function copySimpleNodeSchema(schema: SimpleNodeSchema): SimpleNodeSchema {
+export function copySimpleNodeSchema(schema: SimpleNodeSchema): SimpleNodeSchema {
 	const kind = schema.kind;
 	switch (kind) {
 		case NodeKind.Leaf:
@@ -112,7 +112,7 @@ function copySimpleSchemaWithAllowedTypes(
 ): SimpleMapNodeSchema | SimpleArrayNodeSchema | SimpleRecordNodeSchema {
 	return {
 		kind: schema.kind,
-		allowedTypesIdentifiers: schema.allowedTypesIdentifiers,
+		simpleAllowedTypes: schema.simpleAllowedTypes,
 		metadata: schema.metadata,
 		persistedMetadata: schema.persistedMetadata,
 	};
@@ -122,19 +122,88 @@ function copySimpleObjectSchema(schema: SimpleObjectNodeSchema): SimpleObjectNod
 	const fields: Map<string, SimpleObjectFieldSchema> = new Map();
 	for (const [propertyKey, field] of schema.fields) {
 		// field already is a SimpleObjectFieldSchema, but copy the subset of the properties needed by this interface to get a clean simple object.
-		fields.set(propertyKey, {
+		const simpleField = {
 			kind: field.kind,
-			allowedTypesIdentifiers: field.allowedTypesIdentifiers,
+			simpleAllowedTypes: field.simpleAllowedTypes,
 			metadata: field.metadata,
 			persistedMetadata: field.persistedMetadata,
 			storedKey: field.storedKey,
-		});
+		};
+
+		fields.set(propertyKey, simpleField);
 	}
 
-	return {
+	const simpleObject = {
 		kind: NodeKind.Object,
 		fields,
 		metadata: schema.metadata,
 		persistedMetadata: schema.persistedMetadata,
+		allowUnknownOptionalFields: schema.allowUnknownOptionalFields,
+	} satisfies SimpleObjectNodeSchema;
+
+	return simpleObject;
+}
+
+/**
+ * Creates a copy of a SimpleTreeSchema without metadata fields. This is useful for comparing deserialized view schemas with in-memory schemas.
+ * metadata and persistedMetadata are not relevant for schema compatibility checks and are not serialized by the Simple Schema serializer.
+ * @see {@link simpleSchemaSerializer.ts} for the serialization logic.
+ *
+ * @param schema - The SimpleTreeSchema to remove fields from.
+ * @param fieldsToRemove - An object specifying which fields to remove.
+ * @returns A new SimpleTreeSchema without the specified fields.
+ */
+export function copySimpleTreeSchemaWithoutMetadata(
+	schema: SimpleTreeSchema,
+): SimpleTreeSchema {
+	const definitions = new Map<string, SimpleNodeSchema>();
+
+	for (const [identifier, nodeSchema] of schema.definitions.entries()) {
+		const kind = nodeSchema.kind;
+		switch (kind) {
+			case NodeKind.Array:
+			case NodeKind.Map:
+			case NodeKind.Record:
+			case NodeKind.Leaf: {
+				const outputNodeSchema = {
+					...nodeSchema,
+					metadata: {},
+					persistedMetadata: undefined,
+				};
+				definitions.set(identifier, outputNodeSchema);
+				break;
+			}
+			case NodeKind.Object: {
+				const outputFields = new Map<string, SimpleObjectFieldSchema>();
+				for (const [propertyKey, fieldSchema] of nodeSchema.fields.entries()) {
+					const outputField: SimpleObjectFieldSchema = {
+						...fieldSchema,
+						metadata: {},
+						persistedMetadata: undefined,
+					};
+					outputFields.set(propertyKey, outputField);
+				}
+				const outputNodeSchema = {
+					...nodeSchema,
+					metadata: {},
+					persistedMetadata: undefined,
+					fields: outputFields,
+				};
+				definitions.set(identifier, outputNodeSchema);
+				break;
+			}
+			default:
+				unreachableCase(kind);
+		}
+	}
+
+	return {
+		root: {
+			kind: schema.root.kind,
+			simpleAllowedTypes: schema.root.simpleAllowedTypes,
+			metadata: {},
+			persistedMetadata: undefined,
+		},
+		definitions,
 	};
 }