tree2: Class based schema (#18350)

## Description

To support recursive schema using classes for the schema is useful to
work around microsoft/TypeScript#55832 .

If we are going to use classes to enable that workaround, and also
create a separate simple-tree specific schema system, there are some
other interesting approaches which can be taken.

If we don't support "Any" as a type allowed in fields, then all schema
are reachable from the root.
This means we can skip the schema library concept, and just pass in the
root schema in the configuration.
This has the side-effect of making the actual schema objects available
programmatically be the actual class objects declared in the schema file
(instead of the classes which those extend, which is what a library
would have captured).
This same reachability from the root also opens the door to supporting
contextual view schema where the same type in different locations in the
tree could have different schema subclasses, and its parent would
unambiguously determine which to use for it.

Thus all together this approach makes it possible to make the tree nodes
instances of classes which the user declared.
This has several benefits:

- Users don't have to use "typeof" or invoke any type meta-functions to
get the node types they want to pass around: just use the class/schema
name as the type.
- Intelisense is much cleaner when referring to types defined in schema:
It just uses the class name. or "typeof ClassName". (These
simplifications are what resolve the d.ts issue noted above with
recursive types)
- normal JS/TS type narrowing with `instanceof` can be used with schema
defined types.
- Its possible to add view/session local state to instances as
properties, as well as adding methods by just putting them in the class
like any other class.
- Since the schema/class defines the API for the node, the
implementation of the tree API implicitly gets defined in a way that is
trivially extensible for adding new node kinds.

TODO:

- [X]  support recursive times.
- [x]  implement runtime behavior for object fields.
- [X]  implement runtime behavior for list indexing.
- [x]  structurally typed maps and lists.
- [x] runtime constructing of hydrated nodes (ensure flex tree is type
erased).
-  runtime constructing and later hydrating of unhydrated nodes.
   - [x] objects
   - [ ] map
   - [ ] list
- [x]  Generation of view schema from simple schema.
- [x] Implement full simple-tree API surface
- [ ] Evaluate impact on simple-tree API (for example exposing of
prototypes impacting deep equals).
- [x] Basic end to end testing
- [ ] Full unit testing.

## Breaking Changes

The `schematize` API for simple-trees not using the new class based APIs
has been renamed to `schematizeOld`:
either rename the call site or migrate to the new class based schema.

Some types which would have collided have their old simple-tree or
flex-tree non class based version's renamed:

```typeScript
TreeNodeSchema as FlexTreeNodeSchema,
TreeListNode as TreeListNodeOld,
Tree as TreeOld,
TreeApi as TreeApiOld,
TreeView as TreeViewOld,
```

The previous version of all these names are now used for class based
APIs.

Author: CraigMacomber

examples/apps/tree-comparison/src/model/newTreeInventoryList.ts

@@ -152,7 +152,7 @@ export class NewTreeInventoryList extends DataObject implements IInventoryList {
 		// 3. On all loads, gets an (untyped) view of the data (the contents can't be accessed directly from the sharedTree).
 		// Then the root2() call applies a typing to the untyped view based on our schema.  After that we can actually
 		// reach in and grab the inventoryItems list.
-		this._inventoryItemList = this.sharedTree.schematize({
+		this._inventoryItemList = this.sharedTree.schematizeOld({
 			initialTree: {
 				inventoryItemList: {
 					// TODO: The list type unfortunately needs this "" key for now, but it's supposed to go away soon.

examples/data-objects/inventory-app/src/inventoryList.ts

@@ -6,24 +6,24 @@
 import { DataObject, DataObjectFactory } from "@fluidframework/aqueduct";
 import {
 	ForestType,
-	ISharedTree,
-	SharedTreeFactory,
-	TreeView,
+	TreeFactory,
+	TreeViewOld,
 	typeboxValidator,
+	ITree,
 } from "@fluid-experimental/tree2";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
 import { Inventory, treeConfiguration } from "./schema";
 
 const treeKey = "tree";
 
-const factory = new SharedTreeFactory({
+const factory = new TreeFactory({
 	jsonValidator: typeboxValidator,
 	forest: ForestType.Reference,
 });
 
 export class InventoryList extends DataObject {
-	#tree?: ISharedTree;
-	#view?: TreeView<Inventory>;
+	#tree?: ITree;
+	#view?: TreeViewOld<Inventory>;
 
 	public get inventory(): Inventory {
 		if (this.#view === undefined)
@@ -32,12 +32,12 @@ export class InventoryList extends DataObject {
 	}
 
 	protected async initializingFirstTime() {
-		this.#tree = this.runtime.createChannel(undefined, factory.type) as ISharedTree;
+		this.#tree = this.runtime.createChannel(undefined, factory.type) as ITree;
 		this.root.set(treeKey, this.#tree.handle);
 	}
 
 	protected async initializingFromExisting() {
-		const handle = this.root.get<IFluidHandle<ISharedTree>>(treeKey);
+		const handle = this.root.get<IFluidHandle<ITree>>(treeKey);
 		if (handle === undefined)
 			throw new Error("map should be populated on creation by 'initializingFirstTime'");
 		this.#tree = await handle.get();

examples/data-objects/inventory-app/src/schema.ts

@@ -3,33 +3,23 @@
  * Licensed under the MIT License.
  */
 
-import {
-	AllowedUpdateType,
-	buildTreeConfiguration,
-	TypedNode,
-	SchemaBuilder,
-} from "@fluid-experimental/tree2";
+import { TreeConfiguration, SchemaFactory } from "@fluid-experimental/tree2";
 
-const builder = new SchemaBuilder({ scope: "com.contoso.app.inventory" });
+const builder = new SchemaFactory("com.contoso.app.inventory");
 
-export type Part = TypedNode<typeof Part>;
-export const Part = builder.object("Part", {
+export class Part extends builder.object("Part", {
 	name: builder.string,
 	quantity: builder.number,
-});
-
-export type Inventory = TypedNode<typeof Inventory>;
-export const Inventory = builder.object("Inventory", {
+}) {}
+export class Inventory extends builder.object("Inventory", {
 	parts: builder.list(Part),
-});
+}) {}
 
-export const treeConfiguration = buildTreeConfiguration({
-	schema: builder.intoSchema(Inventory),
-	allowedSchemaModifications: AllowedUpdateType.None,
-	initialTree: {
-		parts: {
-			// TODO: FieldNodes should not require wrapper object
-			"": [
+export const treeConfiguration = new TreeConfiguration(
+	Inventory,
+	() =>
+		new Inventory({
+			parts: [
 				{
 					name: "nut",
 					quantity: 0,
@@ -39,6 +29,5 @@ export const treeConfiguration = buildTreeConfiguration({
 					quantity: 0,
 				},
 			],
-		},
-	},
-});
+		}),
+);

examples/version-migration/tree-shim/src/model/newTreeInventoryListController.ts

@@ -87,7 +87,7 @@ export class NewTreeInventoryListController extends EventEmitter implements IInv
 	// TODO: See note in inventoryList.ts for why this duplicative schematizeView call is here.
 	// TODO: initial tree type - and revisit if we get separate schematize/initialize calls
 	public static initializeTree(tree: ISharedTree, initialTree?: any): void {
-		const view = tree.schematize({
+		const view = tree.schematizeOld({
 			initialTree: initialTree ?? {
 				inventoryItemList: {
 					// TODO: The list type unfortunately needs this "" key for now, but it's supposed to go away soon.
@@ -128,7 +128,7 @@ export class NewTreeInventoryListController extends EventEmitter implements IInv
 		// 3. On all loads, gets an (untyped) view of the data (the contents can't be accessed directly from the sharedTree).
 		// Then the root2() call applies a typing to the untyped view based on our schema.  After that we can actually
 		// reach in and grab the inventoryItems list.
-		this._inventoryItemList = this._tree.schematize({
+		this._inventoryItemList = this._tree.schematizeOld({
 			initialTree: {
 				inventoryItemList: {
 					// TODO: The list type unfortunately needs this "" key for now, but it's supposed to go away soon.

experimental/PropertyDDS/packages/property-shared-tree-interop/src/schemaConverter.ts

@@ -11,7 +11,7 @@ import {
 	SchemaBuilder,
 	FieldKind,
 	Any,
-	TreeNodeSchema,
+	FlexTreeNodeSchema as TreeNodeSchema,
 	LazyTreeNodeSchema,
 	brand,
 	Brand,