@cardstack/boxel-cli 0.3.2-unstable.59 → 0.3.2-unstable.60

package/bundled-test-harness/assets/ai-function-generation-test-e58MHziu.js

@@ -0,0 +1,996 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { ar as basicMappings, or as generateJsonSchemaForCardType, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { M as setupOnSave, O as setupCardLogs, j as setupLocalIndexing, rt as setupRenderingTest } from "./mock-matrix-BhFWlMMr.js";
+//#region tests/unit/ai-function-generation-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var cardApi;
+var string;
+var number;
+var biginteger;
+var date;
+var datetime;
+var boolean;
+var primitive;
+var mappings;
+var loader;
+(0, import_qunit.module)("Unit | ai-function-generation-test", function(hooks) {
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	hooks.beforeEach(async function() {
+		cardApi = await loader.import(`${baseRealm.url}card-api`);
+		primitive = cardApi.primitive;
+		string = await loader.import(`${baseRealm.url}string`);
+		number = await loader.import(`${baseRealm.url}number`);
+		biginteger = await loader.import(`${baseRealm.url}big-integer`);
+		date = await loader.import(`${baseRealm.url}date`);
+		datetime = await loader.import(`${baseRealm.url}datetime`);
+		boolean = await loader.import(`${baseRealm.url}boolean`);
+		mappings = await basicMappings(loader);
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}card-api`));
+	const cardDefAttributesProperties = { cardInfo: {
+		properties: {
+			summary: { type: "string" },
+			notes: { type: "string" },
+			cardThumbnailURL: { type: "string" },
+			name: { type: "string" }
+		},
+		type: "object"
+	} };
+	const linkedRelationship = {
+		type: "object",
+		properties: { links: {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		} },
+		required: ["links"]
+	};
+	const linksToManyRelationship = {
+		type: "object",
+		properties: { links: {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		} },
+		required: ["links"]
+	};
+	const cardDefRelationshipsProperties = {
+		"cardInfo.cardThumbnail": linkedRelationship,
+		"cardInfo.theme": linkedRelationship
+	};
+	const cardDefRelationships = {
+		type: "object",
+		properties: cardDefRelationshipsProperties
+	};
+	(0, import_qunit.test)(`generates a simple compliant schema for basic types`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: NumberField } = number;
+		let { default: BooleanField } = boolean;
+		let { default: DateField } = date;
+		let { default: DateTimeField } = datetime;
+		let { default: BigIntegerField } = biginteger;
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "stringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#stringField = (initializeDeferredDecorator(this, "stringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "numberField", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#numberField = (initializeDeferredDecorator(this, "numberField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "booleanField", [field], function() {
+					return contains(BooleanField);
+				});
+			}
+			#booleanField = (initializeDeferredDecorator(this, "booleanField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "dateField", [field], function() {
+					return contains(DateField);
+				});
+			}
+			#dateField = (initializeDeferredDecorator(this, "dateField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "dateTimeField", [field], function() {
+					return contains(DateTimeField);
+				});
+			}
+			#dateTimeField = (initializeDeferredDecorator(this, "dateTimeField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "bigIntegerField", [field], function() {
+					return contains(BigIntegerField);
+				});
+			}
+			#bigIntegerField = (initializeDeferredDecorator(this, "bigIntegerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					stringField: { type: "string" },
+					numberField: { type: "number" },
+					booleanField: { type: "boolean" },
+					dateField: {
+						type: "string",
+						format: "date"
+					},
+					dateTimeField: {
+						type: "string",
+						format: "date-time"
+					},
+					bigIntegerField: {
+						type: "string",
+						pattern: "^-?[0-9]+$"
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`generates a simple compliant schema for nested types`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InnerCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(InnerCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(InnerCard);
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField);
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						properties: { innerStringField: { type: "string" } }
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					"containerField.linkedCard": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCards": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					...cardDefRelationshipsProperties
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`should support contains many`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField);
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						properties: { innerStringField: {
+							type: "array",
+							items: { type: "string" }
+						} }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`should support linksTo`, async function(assert) {
+		let { field, contains, linksTo, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCard: linkedRelationship,
+				linkedCard2: linkedRelationship,
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`should support linksToMany`, async function(assert) {
+		let { field, contains, linksToMany, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(OtherCard);
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCards: {
+					type: "array",
+					items: linksToManyRelationship
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports deeply nested fields`, async function(assert) {
+		let { field, contains, linksTo, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class PetCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class FriendField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pet", [field], function() {
+					return linksTo(PetCard);
+				});
+			}
+			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+		}
+		class ChildField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friend", [field], function() {
+					return contains(FriendField);
+				});
+			}
+			#friend = (initializeDeferredDecorator(this, "friend"), void 0);
+		}
+		class ParentCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "child", [field], function() {
+					return contains(ChildField);
+				});
+			}
+			#child = (initializeDeferredDecorator(this, "child"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(ParentCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				...cardDefAttributesProperties,
+				name: { type: "string" },
+				child: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						friend: {
+							type: "object",
+							properties: { name: { type: "string" } }
+						}
+					}
+				}
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				"child.friend.pet": linkedRelationship,
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`generates correct schema for nested linksTo and linksToMany fields`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class Country extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class TravelGoal extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "goalTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#goalTitle = (initializeDeferredDecorator(this, "goalTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return linksTo(Country);
+				});
+			}
+			#country = (initializeDeferredDecorator(this, "country"), void 0);
+		}
+		class Traveler extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "countryOfOrigin", [field], function() {
+					return linksTo(Country);
+				});
+			}
+			#countryOfOrigin = (initializeDeferredDecorator(this, "countryOfOrigin"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "countriesVisited", [field], function() {
+					return linksToMany(Country);
+				});
+			}
+			#countriesVisited = (initializeDeferredDecorator(this, "countriesVisited"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "nextTravelGoal", [field], function() {
+					return contains(TravelGoal);
+				});
+			}
+			#nextTravelGoal = (initializeDeferredDecorator(this, "nextTravelGoal"), void 0);
+		}
+		class TripInfo extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "traveler", [field], function() {
+					return contains(Traveler);
+				});
+			}
+			#traveler = (initializeDeferredDecorator(this, "traveler"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TripInfo, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					traveler: {
+						type: "object",
+						properties: {
+							name: { type: "string" },
+							nextTravelGoal: {
+								type: "object",
+								properties: { goalTitle: { type: "string" } }
+							}
+						}
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					...cardDefRelationshipsProperties,
+					"traveler.countryOfOrigin": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"traveler.countriesVisited": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					"traveler.nextTravelGoal.country": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					}
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`skips over fields that can't be recognised`, async function(assert) {
+		let _primitive;
+		assert.expect(2);
+		let { field, contains, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends FieldDef {
+			static {
+				_primitive = primitive;
+			}
+			static {
+				this.displayName = "NewField";
+			}
+			static {
+				this[_primitive] = void 0;
+			}
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "skipField", [field], function() {
+					return contains(NewField);
+				});
+			}
+			#skipField = (initializeDeferredDecorator(this, "skipField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					keepField: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+		try {
+			generateJsonSchemaForCardType(TestCard, cardApi, mappings, { strict: true });
+		} catch (error) {
+			assert.strictEqual(error.message, "No schema found for field 'skipField'. Ensure the field type is defined in the mappings.", "Expected an error to be thrown about the missing field");
+		}
+	});
+	(0, import_qunit.test)(`handles subclasses`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends StringField {
+			static {
+				this.displayName = "NewField";
+			}
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return contains(NewField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					keepField: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`handles subclasses within nested fields`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends StringField {
+			static {
+				this.displayName = "NewField";
+			}
+		}
+		class ContainingField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return containsMany(NewField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "containingField", [field], function() {
+					return contains(ContainingField);
+				});
+			}
+			#containingField = (initializeDeferredDecorator(this, "containingField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containingField: {
+						type: "object",
+						properties: { keepField: {
+							type: "array",
+							items: { type: "string" }
+						} }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on fields`, async function(assert) {
+		let { field, contains, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						description: "Desc #1",
+						properties: { innerStringField: { type: "string" } }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on nested fields`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InnerCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField, { description: "Desc #2" });
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(InnerCard, { description: "Desc #3" });
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(InnerCard);
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(InnerCard, { description: "Desc #4" });
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards2", [field], function() {
+					return linksToMany(InnerCard);
+				});
+			}
+			#linkedCards2 = (initializeDeferredDecorator(this, "linkedCards2"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						description: "Desc #1",
+						properties: { innerStringField: {
+							type: "string",
+							description: "Desc #2"
+						} }
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					"containerField.linkedCard": {
+						type: "object",
+						description: "Desc #3",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCard2": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCards": {
+						type: "array",
+						description: "Desc #4",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					"containerField.linkedCards2": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					...cardDefRelationshipsProperties
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions in linksTo`, async function(assert) {
+		let { field, contains, linksTo, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(OtherCard, { description: "linked card" });
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCard: {
+					type: "object",
+					properties: { links: {
+						type: "object",
+						properties: { self: { type: "string" } },
+						required: ["self"]
+					} },
+					required: ["links"]
+				},
+				linkedCard2: {
+					type: "object",
+					description: "linked card",
+					properties: { links: {
+						type: "object",
+						properties: { self: { type: "string" } },
+						required: ["self"]
+					} },
+					required: ["links"]
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions in linksToMany`, async function(assert) {
+		let { field, contains, linksToMany, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				this.displayName = "TestCard";
+			}
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(OtherCard, { description: "linked cards" });
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCards: {
+					type: "array",
+					description: "linked cards",
+					items: {
+						type: "object",
+						properties: { links: {
+							type: "object",
+							properties: { self: { type: "string" } },
+							required: ["self"]
+						} },
+						required: ["links"]
+					}
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on containsMany fields`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return containsMany(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "array",
+						description: "Desc #1",
+						items: {
+							type: "object",
+							properties: { innerStringField: { type: "string" } }
+						}
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+});
+//#endregion