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

package/src/simple-tree/schemaFactoryRecursive.ts

@@ -3,30 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { FlexTreeNode, Unenforced, isFlexTreeNode } from "../feature-libraries/index.js";
+import { Unenforced } from "../feature-libraries/index.js";
 import { RestrictiveReadonlyRecord } from "../util/index.js";
+import { InsertableObjectFromSchemaRecord } from "./objectNode.js";
+
 import {
 	FieldKind,
 	FieldSchema,
 	ImplicitAllowedTypes,
 	ImplicitFieldSchema,
-	InsertableObjectFromSchemaRecord,
 	InsertableTreeNodeFromImplicitAllowedTypes,
 	NodeKind,
-	TreeNodeSchema,
 	TreeNodeSchemaClass,
 	WithType,
 } from "./schemaTypes.js";
-import { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
 import { TreeNode } from "./types.js";
-import {
-	FieldSchemaUnsafe,
-	InsertableObjectFromSchemaRecordUnsafe,
-	InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
-	ObjectFromSchemaRecordUnsafe,
-	TreeArrayNodeUnsafe,
-	TreeMapNodeUnsafe,
-} from "./typesUnsafe.js";
+import { FieldSchemaUnsafe } from "./typesUnsafe.js";
 
 export function createFieldSchemaUnsafe<
 	Kind extends FieldKind,
@@ -40,10 +32,22 @@ export function createFieldSchemaUnsafe<
 }
 
 /**
- * Extends SchemaFactory with utilities for recursive schema.
- * @see {@link ValidateRecursiveSchema}
+ * Compile time check for validity of a recursive schema.
+ *
+ * @example
+ * ```typescript
+ * class Test extends sf.arrayRecursive("Test", [() => Test]) {}
+ * {
+ *     type _check = ValidateRecursiveSchema<typeof Test>;
+ * }
+ * ```
  * @remarks
- * This is separated from {@link SchemaFactory} as these APIs are more experimental and may be stabilized independently.
+ * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases of malformed schema.
+ * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.
+ * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,
+ * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).
+ *
+ * # Recursive Schema
  *
  * The non-recursive versions of the schema building methods will run into several issues when used recursively.
  * Consider the following example:
@@ -62,7 +66,7 @@ export function createFieldSchemaUnsafe<
  * This would be a runtime error if the TypeScript compiler allowed it.
  * This can be fixed by wrapping the type in a function, which also requires explicitly listing the allowed types in an array (`[() => Test]`).
  *
- * 3. TypeScript fails to infer the recursive type and falls back to `any` with the warning or error (depending on the compiler configuration):
+ * 3. TypeScript fails to infer the recursive type and falls back to `any` with this warning or error (depending on the compiler configuration):
  * `'Test' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`.
  * This issue is what the specialized recursive schema building methods fix.
  * This fix comes at a cost: to make the recursive cases work, the `extends` clauses had to be removed.
@@ -72,7 +76,7 @@ export function createFieldSchemaUnsafe<
  * Instead the nested nodes must be created explicitly using the construction like`new Test([new Test([])])`.
  *
  * 4. It is using "POJO" mode since it's not explicitly declaring a new class.
- * This means that if the schema generated d.ts files replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.
+ * This means that the generated d.ts files for the schema replace recursive references with `any`, breaking use of recursive schema across compilation boundaries.
  * This is fixed by explicitly creating a class which extends the returned schema.
  *
  * All together, the fixed version looks like:
@@ -89,182 +93,22 @@ export function createFieldSchemaUnsafe<
  * class Test extends sf.arrayRecursive("Test", () => Test) {} // Bad
  * ```
  * This schema will still compile, and some (but not all) usages of it may look like they work correctly while other usages will produce generally unintelligible compile errors.
- * This issue can be partially mitigated using {@link ValidateRecursiveSchema}.
- * @sealed @beta
- */
-export class SchemaFactoryRecursive<
-	TScope extends string,
-	TName extends number | string = string,
-> extends SchemaFactory<TScope, TName> {
-	/**
-	 * {@link SchemaFactory.object} except tweaked to work better for recursive types.
-	 * @remarks
-	 * This version of {@link SchemaFactory.object} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 */
-	public objectRecursive<
-		const Name extends TName,
-		const T extends Unenforced<RestrictiveReadonlyRecord<string, ImplicitFieldSchema>>,
-	>(name: Name, t: T) {
-		return this.object(
-			name,
-			t as T & RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
-		) as unknown as TreeNodeSchemaClass<
-			ScopedSchemaName<TScope, Name>,
-			NodeKind.Object,
-			TreeNode & ObjectFromSchemaRecordUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,
-			object & InsertableObjectFromSchemaRecordUnsafe<T>,
-			false,
-			T
-		>;
-	}
-
-	/**
-	 * {@link SchemaFactory.optional} except tweaked to work better for recursive types.
-	 * @remarks
-	 * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 */
-	public optionalRecursive<const T extends Unenforced<readonly (() => TreeNodeSchema)[]>>(t: T) {
-		return createFieldSchemaUnsafe(FieldKind.Optional, t);
-	}
-
-	/**
-	 * `SchemaFactory.array` except tweaked to work better for recursive types.
-	 * @remarks
-	 * This version of `SchemaFactory.array` has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 *
-	 * Additionally `ImplicitlyConstructable` is disabled (forcing use of constructor) to avoid
-	 * `error TS2589: Type instantiation is excessively deep and possibly infinite.`
-	 * which otherwise gets reported at sometimes incorrect source locations that vary based on incremental builds.
-	 */
-	public arrayRecursive<
-		const Name extends TName,
-		const T extends Unenforced<ImplicitAllowedTypes>,
-	>(name: Name, allowedTypes: T) {
-		class RecursiveArray extends this.namedArray_internal(
-			name,
-			allowedTypes as T & ImplicitAllowedTypes,
-			true,
-			false,
-		) {
-			public constructor(
-				data:
-					| Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T & ImplicitAllowedTypes>>
-					| FlexTreeNode,
-			) {
-				if (isFlexTreeNode(data)) {
-					super(data as any);
-				} else {
-					super(data);
-				}
-			}
-		}
-
-		return RecursiveArray as TreeNodeSchemaClass<
-			ScopedSchemaName<TScope, Name>,
-			NodeKind.Array,
-			TreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,
-			{
-				/**
-				 * Iterator for the iterable of content for this node.
-				 * @privateRemarks
-				 * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
-				 * the following compile error when declaring the recursive schema:
-				 * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
-				 * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
-				 *
-				 * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
-				 * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
-				 */
-				[Symbol.iterator](): Iterator<InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>;
-			},
-			false,
-			T
-		>;
-	}
-
-	/**
-	 * `SchemaFactory.map` except tweaked to work better for recursive types.
-	 * @remarks
-	 * This version of `SchemaFactory.map` uses the same workarounds as {@link SchemaFactoryRecursive.arrayRecursive}
-	 */
-	public mapRecursive<Name extends TName, const T extends Unenforced<ImplicitAllowedTypes>>(
-		name: Name,
-		allowedTypes: T,
-	) {
-		class MapSchema extends this.namedMap_internal(
-			name,
-			allowedTypes as T & ImplicitAllowedTypes,
-			true,
-			false,
-		) {
-			public constructor(
-				data:
-					| Iterable<
-							[
-								string,
-								InsertableTreeNodeFromImplicitAllowedTypes<
-									T & ImplicitAllowedTypes
-								>,
-							]
-					  >
-					| FlexTreeNode,
-			) {
-				if (isFlexTreeNode(data)) {
-					super(data as any);
-				} else {
-					super(new Map(data));
-				}
-			}
-		}
-
-		return MapSchema as TreeNodeSchemaClass<
-			ScopedSchemaName<TScope, Name>,
-			NodeKind.Map,
-			TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,
-			{
-				/**
-				 * Iterator for the iterable of content for this node.
-				 * @privateRemarks
-				 * Wrapping the constructor parameter for recursive arrays and maps in an inlined object type avoids (for unknown reasons)
-				 * the following compile error when declaring the recursive schema:
-				 * `Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.`
-				 * To benefit from this without impacting the API, the definition of `Iterable` has been inlined as such an object.
-				 *
-				 * If this workaround is kept, ideally this comment would be deduplicated with the other instance of it.
-				 * Unfortunately attempts to do this failed to avoid the compile error this was introduced to solve.
-				 */
-				[Symbol.iterator](): Iterator<
-					[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]
-				>;
-			},
-			false,
-			T
-		>;
-	}
-}
-
-/**
- * Compile time check for validity of a recursive schema.
+ * This issue can be partially mitigated using {@link ValidateRecursiveSchema}:
  *
- * @example
  * ```typescript
- * class Test extends sf.arrayRecursive("Test", [() => Test]) {}
+ * class Test extends sf.arrayRecursive("Test", () => Test) {} // Bad
  * {
- *     type _check = ValidateRecursiveSchema<typeof Test>;
+ *     type _check = ValidateRecursiveSchema<typeof Test>; // Reports compile error due to invalid schema above.
  * }
  * ```
- * @remarks
- * The type of a recursive schema can be passed to this, and a compile error will be produced for some of the cases which the schema in malformed.
- * This can be used to help mitigate the issue that recursive schema definitions are {@link Unenforced}.
- * If an issue is encountered where a mistake in a recursive schema is made which produces an invalid schema but is not rejected by this checker,
- * it should be considered a bug and this should be updated to handle that case (or have a disclaimer added to these docs that it misses that case).
+ *
  * @privateRemarks
  * There are probably mistakes this misses: it's hard to guess all the wrong things people will accidentally do and defend against them.
  * Hopefully over time this can grow toward being robust, at least for common mistakes.
  *
  * This check duplicates logic that ideally would be entirely decided by the actual schema building methods.
  * Therefore changes to those methods may require updating `ValidateRecursiveSchema`.
- * @beta
+ * @public
  */
 export type ValidateRecursiveSchema<
 	// Recursive types should always be using TreeNodeSchemaClass (not TreeNodeSchemaNonClass) as thats part of the requirements for the type to work across compilation boundaries correctly.
@@ -276,9 +120,12 @@ export type ValidateRecursiveSchema<
 		// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.
 		TreeNode & WithType<T["identifier"]>,
 		// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.
-		// These match whats defined in the methods on `SchemaFactoryRecursive` except they do not use `Unenforced`.
+		// These match whats defined in the recursive methods on `SchemaFactory` except they do not use `Unenforced`.
 		{
-			[NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<string, FieldSchema>
+			[NodeKind.Object]: T["info"] extends RestrictiveReadonlyRecord<
+				string,
+				ImplicitFieldSchema
+			>
 				? InsertableObjectFromSchemaRecord<T["info"]>
 				: unknown;
 			[NodeKind.Array]: T["info"] extends ImplicitAllowedTypes
@@ -292,7 +139,7 @@ export type ValidateRecursiveSchema<
 		false,
 		// Info: What's passed to the method to create the schema. Constraining these here should be about as effective as if the actual constraints existed on the actual method itself.
 		{
-			[NodeKind.Object]: RestrictiveReadonlyRecord<string, FieldSchema>;
+			[NodeKind.Object]: RestrictiveReadonlyRecord<string, ImplicitFieldSchema>;
 			[NodeKind.Array]: ImplicitAllowedTypes;
 			[NodeKind.Map]: ImplicitAllowedTypes;
 		}[T["kind"]]

package/src/simple-tree/schemaTypes.ts

@@ -4,45 +4,13 @@
  */
 
 import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { MakeNominal, RestrictiveReadonlyRecord } from "../util/index.js";
-import { FlexListToUnion, LazyItem } from "../feature-libraries/index.js";
-import { Unhydrated, TreeNode } from "./types.js";
+import { Lazy } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-/**
- * Helper used to produce types for object nodes.
- * @public
- */
-export type ObjectFromSchemaRecord<
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
-> = {
-	-readonly [Property in keyof T]: TreeFieldFromImplicitField<T[Property]>;
-};
-
-/**
- * Helper used to produce types for object nodes.
- * @public
- */
-export type TreeObjectNode<T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>> =
-	object & TreeNode & ObjectFromSchemaRecord<T>;
-
-/**
- * Helper used to produce types for:
- *
- * 1. Insertable content which can be used to construct an object node.
- *
- * 2. Insertable content which is an unhydrated object node.
- *
- * 3. Union of 1 and 2.
- *
- * @privateRemarks TODO: consider separating these cases into different types.
- *
- * @public
- */
-export type InsertableObjectFromSchemaRecord<
-	T extends RestrictiveReadonlyRecord<string, ImplicitFieldSchema>,
-> = {
-	readonly [Property in keyof T]: InsertableTreeFieldFromImplicitField<T[Property]>;
-};
+import { FlexListToUnion, LazyItem, isLazy } from "../feature-libraries/index.js";
+import { MakeNominal, brand, isReadonlyArray } from "../util/index.js";
+import { Unhydrated } from "./types.js";
+import { FieldKey } from "../core/index.js";
 
 /**
  * Schema for a tree node.
@@ -171,6 +139,12 @@ export enum FieldKind {
 	 * Only allows exactly one child.
 	 */
 	Required,
+	/**
+	 * A special field used for node identifiers.
+	 * @remarks
+	 * Only allows exactly one child.
+	 */
+	Identifier,
 }
 
 /**
@@ -198,6 +172,85 @@ export enum NodeKind {
 	Leaf,
 }
 
+/**
+ * Maps from a view key to its corresponding {@link FieldProps.key | stored key} for the provided
+ * {@link ImplicitFieldSchema | field schema}.
+ *
+ * @remarks
+ * If an explicit stored key was specified in the schema, it will be used.
+ * Otherwise, the stored key is the same as the view key.
+ */
+export function getStoredKey(viewKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {
+	return brand(getExplicitStoredKey(fieldSchema) ?? viewKey);
+}
+
+/**
+ * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
+ * Otherwise, returns undefined.
+ */
+export function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {
+	return fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;
+}
+
+/**
+ * Additional information to provide to a {@link FieldSchema}.
+ *
+ * @public
+ */
+export interface FieldProps {
+	/**
+	 * The unique identifier of a field, used in the persisted form of the tree.
+	 *
+	 * @remarks
+	 * If not explicitly set via the schema, this is the same as the schema's property key.
+	 *
+	 * Specifying a stored key that differs from the property key is particularly useful in refactoring scenarios.
+	 * To update the developer-facing API, while maintaining backwards compatibility with existing SharedTree data,
+	 * you can change the property key and specify the previous property key as the stored key.
+	 *
+	 * Notes:
+	 *
+	 * - Stored keys have no impact on standard JavaScript behavior, on tree nodes. For example, `Object.keys`
+	 * will always return the property keys specified in the schema, ignoring any stored keys that differ from
+	 * the property keys.
+	 *
+	 * - When specifying stored keys in an object schema, you must ensure that the final set of stored keys
+	 * (accounting for those implicitly derived from property keys) contains no duplicates.
+	 * This is validated at runtime.
+	 *
+	 * @example Refactoring code without breaking compatibility with existing data
+	 *
+	 * Consider some existing object schema:
+	 *
+	 * ```TypeScript
+	 * class Point extends schemaFactory.object("Point", {
+	 * 	xPosition: schemaFactory.number,
+	 * 	yPosition: schemaFactory.number,
+	 * 	zPosition: schemaFactory.optional(schemaFactory.number),
+	 * });
+	 * ```
+	 *
+	 * Developers using nodes of this type would access the the `xPosition` property as `point.xPosition`.
+	 *
+	 * We would like to refactor the schema to omit "Position" from the property keys, but application data has
+	 * already been persisted using the original property keys. To maintain compatibility with existing data,
+	 * we can refactor the schema as follows:
+	 *
+	 * ```TypeScript
+	 * class Point extends schemaFactory.object("Point", {
+	 * 	x: schemaFactory.required(schemaFactory.number, { key: "xPosition" }),
+	 * 	y: schemaFactory.required(schemaFactory.number, { key: "yPosition" }),
+	 * 	z: schemaFactory.optional(schemaFactory.number, { key: "zPosition" }),
+	 * });
+	 * ```
+	 *
+	 * Now, developers can access the `x` property as `point.x`, while existing data can still be collaborated on.
+	 *
+	 * @defaultValue If not specified, the key that is persisted is the property key that was specified in the schema.
+	 */
+	readonly key?: string;
+}
+
 /**
  * All policy for a specific field,
  * including functionality that does not have to be kept consistent across versions or deterministic.
@@ -215,15 +268,68 @@ export class FieldSchema<
 	 */
 	protected _typeCheck?: MakeNominal;
 
+	private readonly lazyTypes: Lazy<ReadonlySet<TreeNodeSchema>>;
+
 	/**
-	 * @param kind - The [kind](https://en.wikipedia.org/wiki/Kind_(type_theory)) of this field.
-	 * Determine the multiplicity, viewing and editing APIs as well as the merge resolution policy.
-	 * @param allowedTypes - What types of tree nodes are allowed in this field.
+	 * What types of tree nodes are allowed in this field.
+	 * @remarks Counterpart to {@link FieldSchema.allowedTypes}, with any lazy definitions evaluated.
 	 */
+	public get allowedTypeSet(): ReadonlySet<TreeNodeSchema> {
+		return this.lazyTypes.value;
+	}
+
 	public constructor(
+		/**
+		 * The {@link https://en.wikipedia.org/wiki/Kind_(type_theory) | kind } of this field.
+		 * Determines the multiplicity, viewing and editing APIs as well as the merge resolution policy.
+		 */
 		public readonly kind: Kind,
+		/**
+		 * What types of tree nodes are allowed in this field.
+		 */
 		public readonly allowedTypes: Types,
-	) {}
+		/**
+		 * Optional properties associated with the field.
+		 */
+		public readonly props?: FieldProps,
+	) {
+		this.lazyTypes = new Lazy(() => normalizeAllowedTypes(this.allowedTypes));
+	}
+}
+
+/**
+ * Normalizes a {@link ImplicitFieldSchema} to a {@link FieldSchema}.
+ */
+export function normalizeFieldSchema(schema: ImplicitFieldSchema): FieldSchema {
+	return schema instanceof FieldSchema ? schema : new FieldSchema(FieldKind.Required, schema);
+}
+/**
+ * Normalizes a {@link ImplicitAllowedTypes} to a set of {@link TreeNodeSchema}s, by eagerly evaluating any
+ * lazy schema declarations.
+ *
+ * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ */
+export function normalizeAllowedTypes(types: ImplicitAllowedTypes): ReadonlySet<TreeNodeSchema> {
+	const normalized = new Set<TreeNodeSchema>();
+	if (isReadonlyArray(types)) {
+		for (const lazyType of types) {
+			normalized.add(evaluateLazySchema(lazyType));
+		}
+	} else {
+		normalized.add(evaluateLazySchema(types));
+	}
+	return normalized;
+}
+
+function evaluateLazySchema(value: LazyItem<TreeNodeSchema>): TreeNodeSchema {
+	const evaluatedSchema = isLazy(value) ? value() : value;
+	if (evaluatedSchema === undefined) {
+		throw new UsageError(
+			`Encountered an undefined schema. This could indicate that some referenced schema has not yet been instantiated.`,
+		);
+	}
+	return evaluatedSchema;
 }
 
 /**
@@ -233,6 +339,7 @@ export class FieldSchema<
  * @public
  */
 export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
+
 /**
  * Schema for a field of a tree node.
  * @remarks
@@ -336,45 +443,6 @@ export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema
 	? TBuild
 	: never;
 
-/**
- * A map of string keys to tree objects.
- *
- * @privateRemarks
- * Add support for `clear` once we have established merge semantics for it.
- *
- * @public
- */
-export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTypes>
-	extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
-		TreeNode {
-	/**
-	 * Adds or updates an entry in the map with a specified `key` and a `value`.
-	 *
-	 * @param key - The key of the element to add to the map.
-	 * @param value - The value of the element to add to the map.
-	 *
-	 * @remarks
-	 * Setting the value at a key to `undefined` is equivalent to calling {@link TreeMapNode.delete} with that key.
-	 */
-	set(key: string, value: InsertableTreeNodeFromImplicitAllowedTypes<T> | undefined): void;
-
-	/**
-	 * Removes the specified element from this map by its `key`.
-	 *
-	 * @remarks
-	 * Note: unlike JavaScript's Map API, this method does not return a flag indicating whether or not the value was
-	 * deleted.
-	 *
-	 * @privateRemarks
-	 * Regarding the choice to not return a boolean: Since this data structure is distributed in nature, it isn't
-	 * possible to tell whether or not the item was deleted as a result of this method call. Returning a "best guess"
-	 * is more likely to create issues / promote bad usage patterns than offer useful information.
-	 *
-	 * @param key - The key of the element to remove from the map.
-	 */
-	delete(key: string): void;
-}
-
 /**
  * Value that may be stored as a leaf node.
  * @public

package/src/simple-tree/testRecursiveDomain.ts

@@ -10,15 +10,15 @@
  * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.
  */
 
-import { SchemaFactoryRecursive } from "./schemaFactoryRecursive.js";
+import { SchemaFactory } from "./schemaFactory.js";
 // This type is referred to by the base type generated by builder.object.
 // Adding the import of it here prevents TypeScript from generating inline includes for it in the d.ts file.
 // If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.
 // API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
-import { type NodeKind, type FieldKind } from "./schemaTypes.js";
+import { type FieldKind, type NodeKind } from "./schemaTypes.js";
 
-const builder = new SchemaFactoryRecursive("Test Recursive Domain");
+const builder = new SchemaFactory("Test Recursive Domain");
 
 /**
  * To make API-Extractor happy, the base type has to be exported in addition to the actual schema class.