Add some (mostly failing) generic schema type tests (#23936)

## Description

This adds some tests which are generically parameterized over schema
types. These are inspired by ongoing experiments with a Table schema
generator, and issues encountered in its implementation.

Generally it seems that we have some cases where we would really like
TypeScript to simplify conditional type expressions based on extends
clauses, but it does not do so causing code which would otherwise type
check to fail. One such cause is covered in
microsoft/TypeScript#52144 (comment)
but there are likely others.

Author: CraigMacomber

packages/dds/tree/src/test/simple-tree/schemaTypes.spec.ts

@@ -19,6 +19,7 @@ import {
 } from "../../simple-tree/index.js";
 import {
 	type AllowedTypes,
+	type FieldKind,
 	type FieldSchema,
 	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
@@ -45,6 +46,7 @@ import type {
 // eslint-disable-next-line import/no-internal-modules
 import { objectSchema } from "../../simple-tree/objectNode.js";
 import { validateUsageError } from "../utils.js";
+import { TreeAlpha } from "../../shared-tree/index.js";
 
 const schema = new SchemaFactory("com.example");
 
@@ -102,6 +104,15 @@ describe("schemaTypes", () => {
 			type _check6 = requireTrue<areSafelyAssignable<I8, never>>;
 			type _check7 = requireTrue<areSafelyAssignable<I9, never>>;
 			type _check8 = requireTrue<areSafelyAssignable<I10, never>>;
+
+			// eslint-disable-next-line no-inner-declarations
+			function _generic<T extends ImplicitAllowedTypes>() {
+				type I14 = InsertableTreeFieldFromImplicitField<T>;
+				type IOptional = InsertableTreeFieldFromImplicitField<
+					FieldSchema<FieldKind.Optional, T>
+				>;
+				type _check9 = requireAssignableTo<undefined, IOptional>;
+			}
 		}
 
 		// InsertableTreeNodeFromImplicitAllowedTypes
@@ -217,6 +228,17 @@ describe("schemaTypes", () => {
 			// boolean is sometimes a union of true and false, so it can break in its owns special ways
 			type I13 = InsertableField<typeof booleanSchema>;
 			type _check13 = requireTrue<areSafelyAssignable<I13, boolean>>;
+
+			// eslint-disable-next-line no-inner-declarations
+			function _generic<T extends ImplicitAllowedTypes>() {
+				type I14 = InsertableField<T>;
+				type IOptional = InsertableField<FieldSchema<FieldKind.Optional, T>>;
+
+				// Most likely due to the TypeScript conditional type limitation described in https://github.com/microsoft/TypeScript/issues/52144#issuecomment-2686250788
+				// This does not compile. Ideally this would compile:
+				// @ts-expect-error Compiler limitation.
+				type _check9 = requireAssignableTo<undefined, IOptional>;
+			}
 		}
 
 		// NodeFromSchema
@@ -524,4 +546,159 @@ describe("schemaTypes", () => {
 		); // Different custom metadata
 		check(sf.identifier, sf.optional(sf.string), false); // Identifier vs. optional string
 	});
+
+	/**
+	 * Tests for patterns for making generically parameterized schema.
+	 *
+	 * Since the schema themselves can not be generic (at least not in a way thats captured in the stored schema),
+	 * this is done by making generic functions that return schema.
+	 *
+	 * Authoring such functions involves passing generic type parameters into the various schema type utilities,
+	 * and this causes some issues with many of them.
+	 */
+	describe("Generic Schema", () => {
+		// Many of these cases should compile, but don't.
+		// This is likely due to `[FieldSchema<Kind, T>] extends [ImplicitFieldSchema] ? TrueCase : FalseCase` not getting reduced to `TrueCase`.
+		// This could be due to the compiler limitation noted in https://github.com/microsoft/TypeScript/issues/52144#issuecomment-2686250788
+
+		/**
+		 * Tests where the generic code constructs TreeNodes for the generic it's defining.
+		 * This scenario seems to be particularly problematic as the {@link Input} types seems to perform especially poorly due
+		 * to them using non distributive conditional types, which hits the issue noted above.
+		 */
+		it("Generic container construction", () => {
+			const sf = new SchemaFactory("test");
+
+			/**
+			 * Define a generic container which holds the provided `T` directly as an implicit field schema.
+			 */
+			function makeInstanceImplicit<T extends ImplicitAllowedTypes>(
+				schemaTypes: T,
+				content: InsertableTreeFieldFromImplicitField<T>,
+			) {
+				class GenericContainer extends sf.object("GenericContainer", {
+					content: schemaTypes,
+				}) {}
+
+				// Both create and the constructor type check as desired.
+				const _created = TreeAlpha.create(GenericContainer, { content });
+				return new GenericContainer({ content });
+			}
+
+			/**
+			 * Define a generic container which holds the provided `T` in a required field.
+			 *
+			 * This should function identically to the implicit one, but it doesn't.
+			 */
+			function makeInstanceRequired<T extends ImplicitAllowedTypes>(
+				schemaTypes: T,
+				content: InsertableTreeFieldFromImplicitField<T>,
+			) {
+				class GenericContainer extends sf.object("GenericContainer", {
+					content: sf.required(schemaTypes),
+				}) {}
+
+				// Users of the class (if it were returned from this test function with a concrete type instead of a generic one) would be fine,
+				// but using it in this generic context has issues.
+				// Specifically the construction APIs don't type check as desired.
+
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _created = TreeAlpha.create(GenericContainer, { content });
+				// @ts-expect-error Compiler limitation, see comment above.
+				return new GenericContainer({ content });
+			}
+
+			/**
+			 * Define a generic container which holds the provided `T` in an optional field.
+			 */
+			function makeInstanceOptional<T extends ImplicitAllowedTypes>(
+				schemaTypes: T,
+				content: InsertableTreeFieldFromImplicitField<T> | undefined,
+			) {
+				class GenericContainer extends sf.object("GenericContainer", {
+					content: sf.optional(schemaTypes),
+				}) {}
+
+				// Like with the above case, TypeScript fails to simplify the input types, and these do not build.
+
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _createdEmpty = TreeAlpha.create(GenericContainer, { content: undefined });
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _created = TreeAlpha.create(GenericContainer, { content });
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _constructedEmpty = new GenericContainer({ content: undefined });
+				// @ts-expect-error Compiler limitation, see comment above.
+				return new GenericContainer({ content });
+			}
+
+			/**
+			 * Define a generic container which holds the provided `T` in an optional field, using objectRecursive.
+			 * This case is included to highlight one scenario where the compiler limitation does not occur due to simpler typing.
+			 */
+			function makeInstanceOptionalRecursive<T extends ImplicitAllowedTypes>(
+				schemaTypes: T,
+				content: InsertableTreeFieldFromImplicitField<T> | undefined,
+			) {
+				class GenericContainer extends sf.objectRecursive("GenericContainer", {
+					content: sf.optional(schemaTypes),
+				}) {}
+
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _createdEmpty = TreeAlpha.create(GenericContainer, { content: undefined });
+				// @ts-expect-error Compiler limitation, see comment above.
+				const _created = TreeAlpha.create(GenericContainer, { content });
+				const _constructedEmpty = new GenericContainer({ content: undefined }); // This one works.
+				// @ts-expect-error Compiler limitation, see comment above.
+				return new GenericContainer({ content });
+			}
+		});
+
+		it("Generic InsertableTreeFieldFromImplicitField", <T extends ImplicitAllowedTypes>() => {
+			type Required = FieldSchema<FieldKind.Required, T>;
+
+			type ArgFieldImplicit2 = InsertableTreeFieldFromImplicitField<T>;
+			type ArgFieldRequired2 = InsertableTreeFieldFromImplicitField<Required>;
+
+			// We would expect a required field and an implicitly required field to have the same types.
+			// This is normally true, but is failing when the schema is generic due to the compiler limitation noted above.
+
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check5 = requireAssignableTo<ArgFieldRequired2, ArgFieldImplicit2>;
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check6 = requireAssignableTo<ArgFieldImplicit2, ArgFieldRequired2>;
+		});
+
+		it("Generic TreeFieldFromImplicitField", <T extends ImplicitAllowedTypes>() => {
+			type Required = FieldSchema<FieldKind.Required, T>;
+
+			type ArgFieldImplicit2 = TreeFieldFromImplicitField<T>;
+			type ArgFieldRequired2 = TreeFieldFromImplicitField<Required>;
+
+			// We would expect a required field and an implicitly required field to have the same types.
+			// This is normally true, but is failing when the schema is generic due to the compiler limitation noted above.
+			// This case is for the node types not the insertable ones, so it was more likely to work, but still fails.
+
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check5 = requireAssignableTo<ArgFieldRequired2, ArgFieldImplicit2>;
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check6 = requireAssignableTo<ArgFieldImplicit2, ArgFieldRequired2>;
+		});
+
+		it("Generic optional field", <T extends ImplicitAllowedTypes>() => {
+			type Optional = FieldSchema<FieldKind.Optional, T>;
+
+			type ArgFieldImplicit = InsertableTreeFieldFromImplicitField<T>;
+			type ArgFieldOptional = InsertableTreeFieldFromImplicitField<Optional>;
+
+			// An optional field should be the same as a required field unioned with undefined. Typescript fails to see this when its generic:
+
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check5 = requireAssignableTo<ArgFieldOptional, ArgFieldImplicit | undefined>;
+			// @ts-expect-error Compiler limitation, see comment above.
+			type _check6 = requireAssignableTo<ArgFieldImplicit | undefined, ArgFieldOptional>;
+
+			// At least this case allows undefined, like recursive object fields, but unlike non recursive object fields.
+			type _check7 = requireAssignableTo<undefined, ArgFieldOptional>;
+		});
+	});
 });